# A million tests are not a proof

Euler's conjecture says that at least n positive nth powers are needed to sum to another positive nth power (n > 2). Lander and Parkin's four-term fifth-power identity refutes it:

27^5 + 84^5 + 110^5 + 133^5 = 144^5.

Exact Python integer verification gives
14,348,907 + 4,182,119,424 + 16,105,100,000 + 41,615,795,893
= 61,917,364,224 = 144^5, with difference zero.

## Finite domains and methods

The tested quadruple domain is Q = {(a,b,c,d): 1 <= a <= b <= c <= d <= 144}, with C(147,4) = 18,671,940 elements. A hit additionally requires a^5+b^5+c^5+d^5=e^5 and d<e<=144. Thus the bounded solution domain is 1<=a<=b<=c<=d<e<=144 (534,017,484 possible quintuples). Exact fifth-power dictionary lookups eliminate the need to enumerate e separately for each quadruple. All equation arithmetic uses Python arbitrary-precision integers, with no approximate roots.

- Sequential: first 1,000,000 quadruples in ascending lexicographic order, without stopping early. Last tuple: (2,113,122,133).
- Random: 1,000,000 uniform draws from Q, with replacement, using Python random.Random(1966). Each draw sorts random.sample(range(147),4) into t and maps coordinate i to t[i]+1-i. This bijection makes sorted quadruples uniform; simply sorting four independent uniform integers would not. Repeated draws count again; unique random tuples were not tracked.
- Structured: store all 10,296 pairs 1<=a<=b<=143 by a^5+b^5, preserving every pair for a shared sum. Enumerate e=2..144, c=1..e-1, d=c..e-1, in that nested ascending order. For each, look up e^5-c^5-d^5 and retain pairs with b<=c. This exhaustively covers the bounded solution domain. Pair construction loops over a then b, ascending.

## Recorded results

| Method | Count and operation | Seconds | Hits |
|---|---|---:|---|
| Sequential | 1,000,000 distinct quadruple tests | 0.148606417 | None |
| Random, seed 1966 | 1,000,000 draws and quadruple tests | 2.033453542 | None |
| Pair-sum | 10,296 pair builds + 497,640 complement lookups | 0.082261459 | (27,84,110,133,144) |

The pair-sum search returned six raw pair matches; imposing b<=c leaves one sorted witness. Pair-table construction took 0.025435625 seconds, included in its total.

These are the original single-run measurements, not fresh benchmarks: Python 3.12.14 on macOS 26.5.1 ARM64; clock time.perf_counter. Random generation is included. Shared power-table preparation is excluded for all methods. The runnable script is euler_fifth_power_searches.py; execute it with Python 3.12 to reproduce counts and seeded draws. New timings will vary.

## Sequential position and random probability

The witness quadruple is at one-based lexicographic position **10,418,944** in Q. Its position is obtained by counting tuples preceding a=27, then b=84, then c=110, then d=133:

1 + sum[a=1..26] C(147-a,3)
  + sum[b=27..83] C(146-b,2)
  + sum[c=84..109] (145-c) + (133-110)
= 10,418,944.

The complete structured search found exactly one sorted solution in Q. Under an independent uniform sampling model, the probability of at least one hit in a million draws is

1 - (1 - 1/18,671,940)^1,000,000
= 0.052147424931232554, approximately **5.21%**.

This probability describes the sampling model, not uncertainty about the already observed deterministic seed-1966 run.

## Interpretation and limits

Quadruple tests, random draws, pair constructions and complement lookups are different operations. Their counts must not be treated as equal units of work or used to infer a universal per-candidate speedup. Sequential and random runs have fixed budgets; the pair-sum run exhausts its bounded domain. The chart compares measured elapsed times for these particular workloads, not equal-work benchmark trials. One replicate provides no timing variability estimate; sampling overhead, dictionary operations, implementation and machine all matter.

The pair-sum method reuses partial sums: roughly O(N^3) complement lookups with O(N^2) storage versus O(N^4) direct sorted-quadruple enumeration.

**Prior knowledge:** the bound 144 was selected because the historical witness was known. This puts a solution inside a small finite domain; an uninformed search would not know a sufficient bound. The witness itself was used for independent verification and a post-search assertion, not as a hard-coded search target. This is a demonstration, not a new discovery.

A million negative tests establish only those tested cases. Exhaustive finite computation can establish a bounded claim when coverage and implementation are justified, but cannot establish an unbounded statement without a finite-reduction argument. One exact counterexample, however, logically disproves a universal claim.

## Source and provenance

L. J. Lander and T. R. Parkin, “Counterexample to Euler’s conjecture on sums of like powers,” Bulletin of the American Mathematical Society 72 (1966), p. 1079. DOI: https://doi.org/10.1090/S0002-9904-1966-11654-3.

Citation metadata was checked with Crossref. The uploaded historical-source-guide.zip was opened and both source-guide.md and source-guide.json were read. Their equation was independently verified with exact arithmetic. The original AMS PDF was blocked by the runtime's network destination check; the guide reports a visual inspection but no PDF is included in that ZIP. That reported inspection is supplied provenance, not an inspection performed by this agent.

Companion files: euler_search_results.json (full precision timings and structured methods/results), euler_search_comparison.png (single-run elapsed times with workload caveats), and the previously saved euler_fifth_power_searches.py.
