Consequently the still-open set has the exact description

This is an exact reduction, not a probabilistic model.

Two useful sanity checks follow immediately.

• [a] \(H_1\not\equiv0\pmod p\), so for a finite cutoff \(N\), primes

\(p>N/2\) cannot mark any \(n\leq N\).

• [a] Pairing \(r\) with \(p-r\) gives \(H_{p-1}\equiv0\pmod p\) for every

odd \(p\). In particular \(2\in B_3\), proving the infinite \(>1\) half

via \([2\cdot3^e,3^{e+1}-1]\).

2.3 Logarithmic-rotation form of exactly what remains

[a] Since the base-\(p\) mantissa is

\(p^{\{\log n/\log p\}}\), (2.3) is equivalently the assertion that there are

infinitely many integers \(n\) such that, simultaneously for every \(p\leq n/2\),

This isolates the global obstacle: the number of rotations and the forbidden

sets both grow with \(n\).

3. Exact finite computation through \(10^8\)

3.1 Algorithms

The standalone standard-library verifier is

runs/erdos291_wave5q_verify.py.

It contains all source code and three checks.

1. [a + d] Factorial-residue interval sieve. For each relevant prime and

\(k

\[ F_0=1,\ S_0=0,\qquad S_k=kS_{k-1}+F_{k-1},\quad F_k=kF_{k-1}\pmod p. \]

Since \(k!\) is a unit modulo \(p\), \(S_k=0\) iff \(k\in B_p\). It then

marks every interval in (2.3).

2. [d] Independent complete implementation. It generates primes with a

separate segmented sieve whose base primes are found by trial division.

It computes modular inverses from

\[ k^{-1}\equiv-\lfloor p/k\rfloor\,(p\bmod k)^{-1}\pmod p \]

and accumulates \(H_k\) directly. Its interval loop is separately written.

3. [d] Direct rational check. Through \(n=10000\), Python Fraction

constructs \(H_n\), lcm constructs \(L_n\), and the program computes

\(\gcd(a_n,L_n)\) literally. Every value agrees with both interval sieves.

[a] Completeness of the finite search. If a bad interval contains some

\(n\leq N\), then \(kp^e\leq N\), hence \(kp\leq N\). Since \(H_1\neq0\),

we have \(k\geq2\), so \(p\leq N/2\), while

\(k\leq\min(p-1,\lfloor N/p\rfloor)\). These are exactly the primes and

digits traversed by both programs. Each program then visits every power

\(p^e\) with \(kp^e\leq N\). Conversely, (2.2) proves that every interval it

marks is genuinely bad. Thus, conditional on exact integer execution, the

finite mask is exhaustive rather than sampled.

The algorithm-complete core of the first computation is:

for p in primes_up_to(N // 2):
    last = min(p - 1, N // p)
    F, S = 1, 0
    for k in range(1, last + 1):
        S = (k * S + F) % p       # S = k! H_k (mod p)
        F = (k * F) % p           # F = k! (mod p)
        if S == 0:
            q = p
            while k * q <= N:
                lo, hi = k*q, min((k+1)*q, N+1)
                bad[lo:hi] = all_ones[:hi-lo]
                q *= p

The complete executable version handles truncation, avoids overflow in the

power loop, computes statistics and hashes, and performs the two independent

cross-checks.

3.2 Verified table

[d] Let \(G(N)=\#\{1\leq n\leq N:(a_n,L_n)=1\}\). The two complete masks

agree at every index through \(10^8\).

| \(N\) | \(G(N)\) | \(N-G(N)\) |

|---:|---:|---:|

| 10 | 7 | 3 |

| 100 | 37 | 63 |

| 1,000 | 145 | 855 |

| 10,000 | 2,641 | 7,359 |

| 100,000 | 20,128 | 79,872 |

| 1,000,000 | 138,902 | 861,098 |

| 10,000,000 | 615,233 | 9,384,767 |

| 100,000,000 | 10,323,214 | 89,676,786 |

Further exact finite facts:

• [d] The good set in \([1,10^8]\) consists of 409 maximal intervals.
• [d] The longest good interval is

\([54,056,489,54,294,791]\), of length 238,303.

• [d] The longest bad interval wholly inside the cutoff is

\([56,896,849,78,489,877]\), of length 21,593,029.

• [d] The last good interval below the cutoff is

\([85,692,049,85,817,885]\); thus 85,817,885 is the largest verified good

value at this cutoff.

• [d] The first sieve found 3,342 relevant zero pairs \((p,k)\) and marked

3,610 prime-power intervals. It considered exactly 3,001,134 primes

through \(50,000,000\).

• [d] SHA-256 of the complete 100,000,001-byte mask

bad[0..100000000], with bad[0]=1, is

da51cc67e4c6912abe8a825998bb92d6403ce07721a290b54a2146ff3f7e73e3.

The independent implementation produced the identical digest.

• [d] Direct exact arithmetic at every \(n\leq10000\) also matched every

entry of the independently downloaded

OEIS A110566 b-file.

The new exhaustive cutoff is \(10^4\) times the range of that b-file.

These counts oscillate strongly with the cutoff because a single prime-power

interval can occupy a macroscopic portion of \([1,N]\). They are not evidence

for a limiting constant, and no extrapolation from the table is used.

3.3 Reproduction

Run from the repository root:

/usr/bin/time -v python3 runs/erdos291_wave5q_verify.py \
  --limit 100000000 \
  --direct-limit 10000 \
  --independent-limit 100000000 \
  > runs/erdos291_wave5q_result.json

Recorded on this VM with Python 3.12.3:

• first full sieve: 16.205426 s;
• direct Fraction check: 1.958539 s;
• independent full sieve: 23.525928 s;
• total wall time reported by the program: 43.430842 s;
• /usr/bin/time elapsed time: 43.49 s;
• maximum resident set: 456,940 KiB.

Artifacts and file hashes:

• verifier:

runs/erdos291_wave5q_verify.py,

SHA-256

6ad3b1796452b735e38e547b9edf405782550d84ffcea510e400989824262a18;

• captured result:

runs/erdos291_wave5q_result.json,

SHA-256

d54d1543ea1e470cc4b9b7bf5bb5c95fb3ff712b53ba8d8f5ec74dae0b26f359.

python3 -m py_compile runs/erdos291_wave5q_verify.py succeeds.

4. Why this does not close the open half

The finite calculation supplies genuine new checked range, but (2.3) makes the

missing uniform statement precise.

• [a] A proof of the open half must show that the complement of the

growing interval union (2.3) is unbounded, or equivalently find infinitely

many integer times satisfying all the growing avoidance constraints (2.4).

• [c] The random model treats a typical prime as imposing a cost close to

\(1-1/p\), so Mertens suggests a surviving proportion on the order of

\(1/\log n\). This is only a model: the base-\(p\) leading digits for

different \(p\) are coupled through the single integer \(n\).

• [a, conditional on the forum's quoted bound] Even granting

\(|B_p|\leq(3^{2/3}/2)p^{2/3}\), that estimate is not by itself a usable

lower-bound sieve for the complement. The unavoidable single digit

\(p-1\in B_p\) already gives a divergent prime-by-prime heuristic cost.

• [b/c] Kronecker equidistribution can control a fixed finite family

once the needed rational independence is assumed. The independence of

\(1/\log p\) for arbitrary finite prime families is itself unproved, and

fixed-dimensional equidistribution supplies no error uniform enough when

the family expands with \(n\). Wu–Yan need only align finitely many bad

intervals to obtain subsequences of high bad density; avoiding every bad

interval up to \(p\leq n/2\) is the opposite and stronger uniform task.

The exact missing lemma can therefore be stated as follows.

> Missing growing-prime avoidance lemma. Prove that there are arbitrarily

> large integers \(n\) for which, for every prime \(p\leq n/2\), the leading

> base-\(p\) digit of \(n\) is outside

> \(B_p=\{k

This lemma is equivalent to the unresolved gcd-\(1\) half by (2.2), so merely

assuming it would be circular. Neither the cited fixed-prime machinery nor

the forum's proposed dependence-baking argument currently supplies it.

[c: cost extrapolation only] A brute-force extension to \(10^9\) with the

same double implementation would scale to roughly 0.12–0.17 single-core hours

and 4–5 GiB RAM (about 7–10 minutes, under one cent of CPU at

\(\$0.05\)/core-hour). It would extend the table but would not address this

uniformity lemma, so I did not spend that compute.

PARTIAL: The open half is reduced exactly to a growing-prime leading-digit avoidance problem, and two independent exhaustive sieves certify 10,323,214 gcd-\(1\) values through \(10^8\); infinitude remains unproved because the required uniform simultaneous-avoidance lemma is missing.