The forward implication takes the least prime factor of \(p-k!\); the

reverse implication exhibits a proper divisor. This is an exact finite

covering formulation, not a heuristic. (a)

It also explains why a fixed CRT construction cannot settle the problem.

If a fixed modulus \(M\) and reduced residue \(a\bmod M\) are used to

produce infinitely many primes, then for every prime \(q\mid M\) and every

\(k\geq q\), \(k!\equiv0\pmod q\) but \(a\not\equiv0\pmod q\). Thus the

fixed primes dividing \(M\) can force compositeness for only finitely many

factorial shifts; the covering moduli must grow with \(l\). (a)

The exact missing statement for this route is therefore a **uniform

growing-dimensional prime/composite covering lemma**: one must show, for

infinitely many \(l\), that the changing union of residue conditions above

contains a prime before \((l+1)!\). A prime-composite tuple statement for

each fixed finite set of shifts is insufficient, because after taking its

prime arbitrarily large, additional factorials become eligible. (a)

6. Why the first standard sieve attempt stalls

This subsection is diagnostic only. It assumes the Hardy–Littlewood

prime-pair heuristic, from

Hardy–Littlewood (1923),

with uniformity far beyond the fixed-shift conjecture. (c)

For fixed even \(h\), the heuristic prime-pair singular series is

For \(h=k!\), all primes \(q\leq k\) divide \(h\), so the Euler products

and Mertens's prime-product theorem formally give

If \(l!\) is of scale \(x\), summing the expected incidences

“\(p\) and \(p-k!\) both prime” for \(2\leq k\leq l\) gives, relative to

the number of primes near \(x\),

(c)

Thus even the conjectural first-moment union bound has constant \(>1\);

an unconditional upper-bound pair sieve has still more loss. Pairwise

estimates alone cannot prove that some primes have zero prime factorial

companions. This route needs control of overlaps involving three and more

simultaneous primes, uniformly for a family whose dimension is

\(l\asymp\log x/\log\log x\). Current fixed-pattern prime-tuple machinery

does not supply that lower-bound/zero-count distribution. (c)

This identifies the wall more precisely than “the problem seems hard”:

the missing input is either

1. the growing-dimensional covering lemma in Section 5, or

2. a uniform lower bound for the zero class in the distribution of

\(\#\{k\leq l:p-k!\text{ is prime}\}\) among primes in a factorial

band.

Both must retain uniformity as \(l\to\infty\); proving a statement for

each fixed \(l\) does not close the problem. (a)

7. Reproducible computation

The complete standalone verifier is

erdos1059_wave6t_verify.py. It uses only

the Python standard library. Its core is an exact odd-only Eratosthenes

sieve followed by the literal strict test:

def is_composite_sieve(n, odd_is_prime):
    return n > 1 and not sieve_is_prime(n, odd_is_prime)

for p in all_sieved_primes:
    ok = True
    f = 1
    k = 1
    while f < p:
        if not is_composite_sieve(p - f, odd_is_prime):
            ok = False
            break
        k += 1
        f *= k
    if ok:
        solutions.append(p)

The full script additionally:

• recomputes an independent trial-division enumeration through \(10^5\)

and asserts equality with the sieve (900 strict solutions);

• uses deterministic 64-bit Miller–Rabin plus explicit divisors for sample

certificates;

• uses wholly independent elementary trial division for the equality

examples \(769\) and \(6\,227\,021\,089\);

• checks the factorial-edge bound on every enumerated solution;
• locates all “nonprime but not composite” false positives among

factorial-plus-one candidates.

Commands run:

python -m py_compile runs/erdos1059_wave6t_verify.py
python runs/erdos1059_wave6t_verify.py \
  --limit 10000000 \
  --output runs/erdos1059_wave6t_1e7.json
python runs/erdos1059_wave6t_verify.py \
  --limit 1000000000 \
  --output runs/erdos1059_wave6t_1e9.json

The \(10^9\) pass sieved all \(50\,847\,534\) primes and took 172.807

single-core seconds, of which 12.354 seconds built the sieve. The exact

artifacts are

erdos1059_wave6t_1e7.json and

erdos1059_wave6t_1e9.json. (d)

Final SHA-256 values at report time:

517944c676525006f2c677777c1101cc03b23306df1e850c39ce0f77171f6f85  erdos1059_wave6t_verify.py
7e53d85cbeac6318415a9de89ada4e5380863f6874a74cb1a148d31b69e853f0  erdos1059_wave6t_1e7.json
d021a71051234706cb1417773f08f733d68c11c95e3540672c28027e7efcc385  erdos1059_wave6t_1e9.json

Extending the same byte-per-odd sieve through \(13!=6\,227\,020\,800\)

would require a 3.11 GB primality bytearray plus the solution list. Linear

scaling from the measured \(10^9\) run predicts about 17.9 single-core

minutes, or 0.30 core-hours, so I did not run it under the few-minute cap.

At a representative commodity CPU rate of USD 0.04–0.10/core-hour, the

CPU charge would be roughly USD 0.01–0.03; it would complete another

finite band but would not address uniform infinitude. (c)

PARTIAL: proved the sharp bound \(p-k!\geq\operatorname{nextprime}(k)^2\), certified equality solutions \(769\) and \(6\,227\,021\,089\), and exactly corrected/enumerated the strict sequence through \(10^9\) (5,901,408 terms); infinitude remains open at a growing-dimensional sieve/covering wall.