Erdős problem #1181 — live audit, exact reduction, and exhaustive finite data

Access/search date: 2026-07-28 UTC.

Result in one paragraph

The mandatory collision gate did not fire: the live page is OPEN, has

0 claimed proofs, and lists no current worker or interested collaborator.

I did not prove the requested uniform constant saving. I obtained two

verifiable pieces of progress:

1. [a] an exact reduction

\[ q(n,k)\ge y \quad\Longleftrightarrow\quad \prod_{\substack{k

together with the resulting sharper exact capacity inequality

\[ \sum_{k

2. [d] an exhaustive determination of

\(\max q(n,\lfloor\log n\rfloor)\) in every logarithmic band

\(1\le\lfloor\log n\rfloor\le20\). This covers all

\(1,318,815,732\) integers

\[ 3\le n\le1,318,815,734

The largest value in the whole range is \(113\), attained uniquely at

\(n=999,852,511\).

The exact unresolved step is not prime counting: below

\((1-c)(\log n)^2\), the forced squarefree prime product is exponentially

smaller than the binomial coefficient by \(\exp((c+o(1))(\log n)^2)\).

One needs a uniform theorem saying that enough of the binomial coefficient

is forced into repeated, small, or very large prime factors. The standard

primorial estimate and Gallagher larger sieve do not supply such a theorem.

Claim labels

• [a] elementary-rigorous: proved below from elementary arithmetic, or a

direct observation from a checked source.

• [b] rigorous-modulo-named-theorem: the deduction is complete after the

explicitly named published theorem is accepted.

• [c] plausible/structural-unverified: a heuristic, diagnosis, or possible

route, not a theorem.

• [d] computational-only: exhaustively checked only in the stated finite

range.

Nothing below claims that problem #1181 is solved.

0. Mandatory live-page gate

Retrieval and collision check

[a, direct source observation] I fetched the rendered DOM of

<https://www.erdosproblems.com/1181> through the Bright Data residential

browser path. Direct datacenter fetching was not used as authority. The live

page displayed:

• status OPEN;
• 0 comments on this problem;
• 0 claimed proofs for this problem;
• Interested in collaborating None;
• Currently working on this problem None;
• This problem looks difficult None;
• This problem looks tractable None;
• last edited 07 March 2026.

Thus neither stop condition applied.

Verbatim live statement

> Let \(q(n,k)\) denote the least prime which does not divide

> \(\prod_{1\leq i\leq k}(n+i)\). Is it true that there exists some \(c>0\)

> such that, for all large \(n\),

> \[ > q(n,\log n)<(1-c)(\log n)^2? > \]

The source marker is [Er79d,p.78]; the only tag is number theory.

Everything mathematical listed on the page

[a, tracker transcription] The page records the elementary bound

from comparison of the primorial with the product of the consecutive

integers.

[c, tracker-reported heuristic] It reports Tao's heuristic from the

comments on problem #457:

[a, tracker transcription] It points to #457 for lower bounds. The

current #457 page reports the complementary construction

for infinitely many \(n\), based on an elaboration sketched by Tao in that

page's comments. This is tracker material, not a claim independently promoted

here to a published theorem.

For the integer-valued second argument, I use the original source's explicit

convention \(k=\lfloor\log n\rfloor\), and every logarithm below is natural.

1. Primary-source and literature audit

Original source

[a, source-verified] The cited paper exists:

> Paul Erdős, “Some unconventional problems in number theory,”

> Acta Mathematica Academiae Scientiarum Hungaricae 33 (1979),

> 71–80, DOI

> <https://doi.org/10.1007/BF01903382>.

I downloaded the scan from the

Erdős publication archive

and extracted page 78. Erdős defines

\(A(n,k)=\prod_{1\le i\le k}(n+i)\), defines \(q(n,k)\) as above, gives the

crude \(q(n,k)<(1+o(1))k\log n\), and then asks the stronger

for all sufficiently large \(n\). He immediately says that he and Pomerance

could not even prove the weaker constant saving from \((\log n)^2\). Thus

the live problem is an exact extraction of the explicitly stated 1979

barrier.

Searches actually performed

[a, search observation; not a theorem] I searched exact phrases and

notation including "q(n,k)", "q(n,[log n])", `"least prime which does

not divide"`, the title of the 1979 paper, and combinations with

consecutive integers and Pomerance. I also queried Crossref and the

OpenAlex citation graph for DOI 10.1007/BF01903382 and inspected titles and

abstracts/full text when relevant. No paper found in those searches states

the uniform upper bound in #1181 or a constant-factor improvement over

\((\log n)^2\). Search misses are not evidence that no such paper exists.

The closest apparently relevant citing paper was M. A. Bennett,

M. Filaseta, and O. Trifonov,

“On the factorization of consecutive integers”,

J. Reine Angew. Math. 629 (2009), 171–200, DOI

<https://doi.org/10.1515/CRELLE.2009.030>. [a, source-verified] Its

introduction and main theorems concern the small-prime and large-prime parts

of binomial coefficients, especially fixed small \(k\) and explicit

Diophantine exceptions. It does not state a bound for

\(k=\lfloor\log n\rfloor\) that fills the gap below.

The live problem itself was only split off from #457 on 7 March 2026. No

claimed proof or discussion had appeared on its page by the access date.

2. Exact arithmetic reduction

Let

Lemma 1: one-prime residue test

[a] If \(p>k\) is prime, then

Indeed, the least positive distance from \(n\) to the next multiple of \(p\)

must be one of \(1,\ldots,k\). If \(n\bmod p=0\), that distance is \(p>k\),

so residue zero is correctly excluded.

Lemma 2: binomial divisibility equivalence

[a] For any real \(y>k\),

python3 runs/erdos1181_wave8i_reverify.py

20  485165196    1318815734    833650539     113     1 (999852511,)  [49.506s]
VERIFIED: scanned 1,318,815,732 integers, 3 <= n <= 1,318,815,734, in 79.711s

a9049328dfdd631d0c9cde45f64932e6c395534455570bdbaa50f686763d2a0c

def scan_band(k, lo, hi, primes, chunk_size):
    q_counts = defaultdict(int)
    terminal_candidates = []
    for start in range(lo, hi + 1, chunk_size):
        stop = min(hi + 1, start + chunk_size)
        candidates = np.arange(start, stop, dtype=np.int64)
        for p in primes:
            if p <= k:
                continue
            before = candidates
            candidates = before[(before % p) >= p - k]
            q_counts[p] += int(before.size - candidates.size)
            if candidates.size == 0:
                terminal_candidates.append((p, tuple(map(int, before))))
                break
        else:
            raise AssertionError("prime limit too small during scan")
    assert sum(q_counts.values()) == hi - lo + 1
    maximum = max(p for p, count in q_counts.items() if count)
    maximizers = []
    for terminal_prime, values in terminal_candidates:
        if terminal_prime == maximum:
            maximizers.extend(values)
    assert len(maximizers) == q_counts[maximum]
    return maximum, tuple(maximizers), dict(sorted(q_counts.items()))