\(A=\bigcup_j\mathcal B'_j\). If

\(\eta_jx_j\le y<\eta_{j+1}x_{j+1}\), then

Hence \(A\) has density zero. But along \(x_j\), its preimage has upper

density at least \(\rho/2\), contradicting the live conjecture. Therefore

(U), and equivalently (UI), must hold. (a)

3. What this isolates, and why standard shortcuts fail

PPT's uniform theorem says precisely that

The missing range in (U) is much larger: \(k=\delta x\), with a bound that

must tend uniformly to zero as \(\delta\downarrow0\). This states the gap

without requiring any structure in the target set. (b)

An \(L^2\) collision shortcut cannot work without truncation:

because \(s(n)=1\) exactly for primes. This is far larger than the \(O(x)\)

energy bound that Cauchy--Schwarz would need to handle every \(o(x)\)-sized

target set. The condition (UI) correctly tolerates this fibre because its

size-biased mass is only \(\pi(x)/x\to0\). **(a) for the fibre identity and

collision obstruction; (b) for the prime-number-theorem asymptotic**

Nor can one impose a fixed bound on the nonprime fibres: PPT Theorem 1.4

constructs values with \(\exp(c\log m/\log\log m)\) preimages in prescribed

proportional intervals. What remains possible, and exactly sufficient, is

the aggregate assertion (UI) that all large fibres together contain only

vanishing input mass. (b)

The prime-factor, residue-class, powerfree, palindrome, two-square, and

missing-digit papers exploit special structure of their respective target

sets. Their statements do not provide (UI) for arbitrary fibres. (b)

4. Exact finite concentration computation

For each cutoff, the verifier computes every \(s(n)\), sorts all positive

fibre multiplicities, and uses (2.1). Therefore every entry \(M_x(k)\) below

is a sharp universal finite bound: every \(\mathcal B\subset\mathbb N\)

with \(|\mathcal B|\le k\) has at most \(M_x(k)\) preimages up to \(x\), and

equality is attained by choosing \(k\) largest fibres. **(a) for sharpness;

(d) for the numerical values**

All logarithms in the table are natural.

| \(x\) | \(\lfloor\sqrt x\rfloor\) | \(M_x\) | \(\lfloor x/\log^2x\rfloor\) | \(M_x\) | \(\lfloor x/\log x\rfloor\) | \(M_x\) |

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

| 100 | 10 | 45 | 4 | 33 | 21 | 63 |

| 1,000 | 31 | 295 | 20 | 259 | 144 | 559 |

| 10,000 | 100 | 2,026 | 117 | 2,121 | 1,085 | 5,126 |

| 100,000 | 316 | 14,758 | 754 | 18,547 | 8,685 | 48,337 |

| 1,000,000 | 1,000 | 113,818 | 5,239 | 167,414 | 72,382 | 446,711 |

| 5,000,000 | 2,236 | 487,831 | 21,014 | 790,980 | 324,150 | 2,136,775 |

At \(x=5{,}000{,}000\), these three sharp captured proportions are

\(0.0975662\), \(0.1581960\), and \(0.4273550\), respectively. Their decrease

over this short range is not asserted to continue asymptotically. (d)

Additional exact diagnostics at \(x=5{,}000{,}000\):

• there are \(2{,}383{,}711\) distinct positive values hit; (d)
• \(F_x(1)=348{,}513=\pi(5{,}000{,}000)\); **(a) for the identity; (d) for

the value**

• excluding \(a=1\), the largest fibre has size \(171\), at \(a=4411\);

(d)

• \(H_x(10)=780{,}860\), \(H_x(100)=371{,}436\), and

\(H_x(1000)=H_x(10000)=348{,}513\); (d)

• the collision energy after removing the \(a=1\) fibre is

\(\sum_{a\ne1}F_x(a)^2=27{,}002{,}756\). (d)

No finite row proves a density statement. Its role is an exact small-case

measurement of the concentration function that the reduction identifies.

(d)

5. Independent verification and computational wall

The standalone verifier is

runs/erdos955_wave7w_reverify.py, SHA-256

3e333279f30b87ddcdfb39256a6fec7fb5da69c0de4aa061d7cfd7de13debad0.

It uses only the Python standard library and recomputes every value through

two independent routes:

1. an additive proper-divisor sieve;

2. an SPF factorisation and the multiplicative product formula for

\(\sigma(n)\).

It also checks \(s(n)=1\) if and only if \(n\) is prime, reconstructs every

table row, and compares the result with embedded exact tuples. (d)

Run:

python3 runs/erdos955_wave7w_reverify.py

The final measured run took about 24 seconds on one core and used about

239 MiB maximum RSS. Straight \(N\log N\) scaling puts the same Python

method at \(N=10^8\) near \(0.15\) core-hours and roughly 5 GiB, and at

\(N=10^9\) near \(1.7\) core-hours and roughly 50 GiB. I did not run those:

larger finite cutoffs cannot supply the uniform \(x\to\infty\) step in (UI).

(d) for the measurement; (c) for the extrapolation

The precise analytic wall is now (UI), not lack of more samples. One needs a

collective estimate for all popular \(s\)-values, strong enough that the

fraction of inputs in fibres larger than fixed \(T\) tends uniformly to zero

as \(T\to\infty\). PPT reaches arbitrary target sets only through

\(x^{1/2+o(1)}\) values; known structured-set arguments do not aggregate over

the \(\delta x\) potentially adversarial targets required here. **(a) for the

equivalence; (b) for the literature boundary**

6. Full verifier source

The following is the exact standalone source used for the certified run.

#!/usr/bin/env python3
"""Independent finite verifier for Erdős problem #955.

The script computes s(n) in two independent ways:

1. an additive proper-divisor sieve;
2. factorisation through a smallest-prime-factor sieve and the product
   formula for sigma(n).

It then computes the exact finite concentration function

    M_x(k) = max_{|B| <= k} #{2 <= n <= x : s(n) in B},

which is the sum of the k largest positive-value fibre sizes.
Only the Python standard library is used.
"""

from __future__ import annotations

import argparse
import math
import time
from array import array
from collections import Counter


DEFAULT_MAX_N = 5_000_000
DEFAULT_CUTOFFS = (
    100,
    1_000,
    10_000,
    100_000,
    1_000_000,
    5_000_000,
)
HEAVY_THRESHOLDS = (10, 100, 1_000, 10_000)
EXPECTED_DEFAULT_ROWS = (
    (100, 57, 25, 3, 21, 114, 10, 45, 4, 33, 21, 63, 25, 0, 0, 0),
    (
        1_000,
        524,
        168,
        6,
        49,
        1_769,
        31,
        295,
        20,
        259,
        144,
        559,
        168,
        168,
        0,
        0,
    ),
    (
        10_000,
        5_024,
        1_229,
        15,
        169,
        24_326,
        100,
        2_026,
        117,
        2_121,
        1_085,
        5_126,
        1_420,
        1_229,
        1_229,
        0,
    ),
    (
        100_000,
        48_748,
        9_592,
        41,
        631,
        323_151,
        316,
        14_758,
        754,
        18_547,
        8_685,
        48_337,
        14_934,
        9_592,
        9_592,
        0,
    ),
    (
        1_000_000,
        480_139,
        78_498,
        92,
        1_891,
        4_304_997,
        1_000,
        113_818,
        5_239,
        167_414,
        72_382,
        446_711,
        153_266,
        78_498,
        78_498,
        78_498,
    ),
    (
        5_000_000,
        2_383_711,
        348_513,
        171,
        4_411,
        27_002_756,
        2_236,
        487_831,
        21_014,
        790_980,
        324_150,
        2_136_775,
        780_860,
        371_436,
        348_513,
        348_513,
    ),
)


def additive_aliquot_sieve(limit: int) -> array:
    """Return s[n] by adding each proper divisor to all larger multiples."""
    values = array("Q", [0]) * (limit + 1)
    for divisor in range(1, limit // 2 + 1):
        for multiple in range(2 * divisor, limit + 1, divisor):
            values[multiple] += divisor
    return values


def smallest_prime_factors(limit: int) -> array:
    """Return an SPF table; a zero entry at n >= 2 means that n is prime."""
    spf = array("I", [0]) * (limit + 1)
    for prime in range(2, math.isqrt(limit) + 1):
        if spf[prime] != 0:
            continue
        for multiple in range(prime * prime, limit + 1, prime):
            if spf[multiple] == 0:
                spf[multiple] = prime
    return spf


def aliquot_from_factorisation(n: int, spf: array) -> int:
    """Compute s(n)=sigma(n)-n from the prime factorisation of n."""
    remaining = n
    sigma = 1
    while remaining > 1:
        prime = spf[remaining] or remaining
        prime_power = 1
        geometric_sum = 1
        while remaining % prime == 0:
            remaining //= prime
            prime_power *= prime
            geometric_sum += prime_power
        sigma *= geometric_sum
    return sigma - n


def verify_all_values(values: array) -> None:
    """Recompute every entry independently using multiplicativity."""
    limit = len(values) - 1
    spf = smallest_prime_factors(limit)
    for n in range(1, limit + 1):
        independent = aliquot_from_factorisation(n, spf)
        if values[n] != independent:
            raise AssertionError(
                f"s({n}) disagrees: divisor sieve={values[n]}, "
                f"factorisation={independent}"
            )
        is_prime = n >= 2 and spf[n] == 0
        if (values[n] == 1) != is_prime:
            raise AssertionError(f"the fibre s(n)=1 disagrees with primality at n={n}")


def concentration_summary(x: int, counts: Counter[int]) -> tuple[int, ...]:
    """Return exact fibre and concentration data at x."""
    # A is a subset of positive integers, so the irrelevant value s(1)=0 is
    # deliberately absent.  The caller starts inserting at n=2.
    multiplicities = sorted(counts.values(), reverse=True)
    prime_fibre = counts[1]
    other_max_fibre = max(count for a, count in counts.items() if a != 1)
    other_max_target = min(
        a for a, count in counts.items() if a != 1 and count == other_max_fibre
    )
    k_sqrt = math.isqrt(x)
    k_log2 = max(1, math.floor(x / math.log(x) ** 2))
    k_log = max(1, math.floor(x / math.log(x)))

    def top_mass(k: int) -> int:
        return sum(multiplicities[:k])

    collision_energy_without_prime_fibre = sum(
        count * count for a, count in counts.items() if a != 1
    )
    heavy_masses = tuple(
        sum(count for count in multiplicities if count > threshold)
        for threshold in HEAVY_THRESHOLDS
    )
    return (
        x,
        len(counts),
        prime_fibre,
        other_max_fibre,
        other_max_target,
        collision_energy_without_prime_fibre,
        k_sqrt,
        top_mass(k_sqrt),
        k_log2,
        top_mass(k_log2),
        k_log,
        top_mass(k_log),
        *heavy_masses,
    )


def compute_table(values: array, cutoffs: tuple[int, ...]) -> list[tuple[int, ...]]:
    counts: Counter[int] = Counter()
    rows: list[tuple[int, ...]] = []
    cutoff_set = set(cutoffs)
    for n in range(2, cutoffs[-1] + 1):
        counts[values[n]] += 1
        if n in cutoff_set:
            rows.append(concentration_summary(n, counts))
    return rows


def print_table(rows: list[tuple[int, ...]]) -> None:
    print(
        "x distinct f(1) other_max other_target energy_without_1 "
        "k_sqrt M_sqrt k_log2 M_log2 k_log M_log "
        + " ".join(f"H_gt_{threshold}" for threshold in HEAVY_THRESHOLDS)
    )
    for row in rows:
        print(" ".join(map(str, row)))
    print()
    print("Ratios M_x(k)/x:")
    for row in rows:
        x = row[0]
        print(
            f"x={x}: sqrt={row[7] / x:.9f}, "
            f"x/log^2x={row[9] / x:.9f}, "
            f"x/logx={row[11] / x:.9f}"
        )


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--max-n",
        type=int,
        default=DEFAULT_MAX_N,
        help=f"largest n to verify (default: {DEFAULT_MAX_N})",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    if args.max_n < 2:
        raise SystemExit("--max-n must be at least 2")
    cutoffs = tuple(x for x in DEFAULT_CUTOFFS if x <= args.max_n)
    if not cutoffs or cutoffs[-1] != args.max_n:
        cutoffs += (args.max_n,)

    started = time.perf_counter()
    values = additive_aliquot_sieve(args.max_n)
    after_additive = time.perf_counter()
    verify_all_values(values)
    after_independent = time.perf_counter()
    rows = compute_table(values, cutoffs)
    finished = time.perf_counter()

    if args.max_n == DEFAULT_MAX_N:
        if tuple(rows) != EXPECTED_DEFAULT_ROWS:
            raise AssertionError("recomputed table differs from the certified table")

    print_table(rows)
    print(
        "PASS: every s(n) was identical under the additive-divisor and "
        "multiplicative-factorisation computations; the exact default table "
        "matches its embedded certificate; and s(n)=1 exactly at primes."
    )
    print(
        f"Timings: additive={after_additive - started:.3f}s, "
        f"independent={after_independent - after_additive:.3f}s, "
        f"table={finished - after_independent:.3f}s, "
        f"total={finished - started:.3f}s"
    )


if __name__ == "__main__":
    main()

PARTIAL: proved an elementary equivalence with uniform size-biased fibre tightness, isolating the exact missing lemma, and exactly certified the sharp finite concentration function through \(x=5{,}000{,}000\); the unrestricted conjecture remains open.