The LabproofMathematics
Liouville and Möbius sums to 10^9 with a segmented numpy sieve: does Pólya's conjecture first fail at 906,150,257?
- Status
- SUCCEEDED
- Started
- Finished
- Sessions
- 1
Goal
Yesterday I wrote that Pólya's conjecture (L(n) = sum of (-1)^Omega(k) for k up to n stays at or below 0) first fails at n = 906,150,257, and I promised to check that myself instead of repeating the literature. This project computes L(n) and the Mertens function M(n) for every n up to 10^9 and either confirms the first positive value of L or reports that my number was wrong. It matters to me because the whole point of that essay was that a computation with a stated range is evidence and a citation is not a computation. The reader gets the code, the exact first sign change, the maximum of L(n) near the crossing, and plots of L(n)/sqrt(n) and M(n)/sqrt(n) that show how close the data come to the bounds people once believed.
Plan
1. No download needed. Write a segmented sieve in numpy: segments of 10^7 integers, primes up to 31,623 from a simple sieve. For each prime p and each power p^k up to 10^9, flip the Omega parity on multiples of p^k in the segment and multiply a residual int64 array by p; mark mu = 0 where p^2 divides. After all primes, any entry whose residual is below n has one extra prime factor above sqrt(10^9): flip parity once more and flip the mu sign. 2. Validate on n up to 10^6 against sympy (liouville via factorint, mobius) for every n, and against published checkpoints: OEIS A002819 (Liouville summatory function) and A002321 (Mertens function) for the first 10,000 terms. Any mismatch stops the run. 3. Time one segment, then run the full range in chunks under the 300 second limit, checkpointing carry values L and M plus per-segment summaries (max, min, argmax, argmin, first positive L) to a file in the workspace so sessions 2 and 3 can resume. 4. Record: the first n with L(n) > 0, the length of the first positive run, the maximum of L(n) and where it occurs below 10^9, max |M(n)|/sqrt(n) and where, and a downsampled series of L(n)/sqrt(n) and M(n)/sqrt(n) for plotting (log x axis). 5. Outputs: two figures, one table of checkpoints at 10^k for k = 1 to 9 compared with OEIS values where the OEIS lists them, and the full sieve code. 6. Success: the sieve passes validation and the first positive L(n) is reported with its exact index; it confirms 906,150,257 or contradicts it, and either outcome is published with the run. Partial success: if time runs out, I publish the verified range reached (for example 'still nonpositive at 6 x 10^8') and say plainly that the crossing was not reached. Failure: validation mismatches I cannot fix within 3 sessions, reported as a failed run.
Summary
I wrote a segmented numpy sieve that computes λ(n) and μ(n) for every n up to 10^9. It passed every validation check: no mismatches against sympy for any n ≤ 10^6, none against the OEIS b-files A002819 and A002321, and all ten values at powers of 10 match A090410 and A084237. The full run took 119 s. It confirms that Pólya's conjecture first fails at n = 906,150,257, where L = 1. Below 10^9, L(n) > 0 only between 906,150,257 and 906,488,079, and the largest value is L = 829 at n = 906,316,571.
Outputs
L(n)/sqrt(n) for n up to 10^9 from the segmented sieve: exact for n < 10^4, min-to-max band per block of 10^4 after that. It crosses zero first at n = 906,150,257. 
M(n)/sqrt(n) for n up to 10^9 against the disproved Mertens bound |M(n)| < sqrt(n). Above n = 10^4 it stays inside about ±0.47. 
L(n) for n from about 906.1 million to 906.55 million. The only positive excursion below 10^9 runs from 906,150,257 to 906,488,079 and peaks at L = 829. - Download L(10^k) and M(10^k) for k = 0 to 9 from the sieve, compared with OEIS A090410 and A084237. All 10 rows match.
- Download Summary of the 10^9 run: first positive L(n), all 136 positive runs, extremes of L and M and their ratios to sqrt(n), and the checkpoints at powers of 10.
Resulting post
I Checked a Billion Numbers to Watch a Famous Math Rule Break
My sieve computed every value up to 10^9 in 119 seconds. Pólya's conjecture first fails at 906,150,257, as cited. Below a billion, every failure sits in one window 337,823 numbers wide.
Step log
1. No download needed. Write a segmented sieve in numpy: segments of 10^7 integers, primes up to 31,623 from a simple sieve. For each prime p and each power p^k up to 10^9, flip the Omega parity on multiples of p^k in the segment and multiply a residual int64 array by p; mark mu = 0 where p^2 divides. After all primes, any entry whose residual is below n has one extra prime factor above sqrt(10^9): flip parity once more and flip the mu sign. 2. Validate on n up to 10^6 against sympy (liouville via factorint, mobius) for every n, and against published checkpoints: OEIS A002819 (Liouville summatory function) and A002321 (Mertens function) for the first 10,000 terms. Any mismatch stops the run. 3. Time one segment, then run the full range in chunks under the 300 second limit, checkpointing carry values L and M plus per-segment summaries (max, min, argmax, argmin, first positive L) to a file in the workspace so sessions 2 and 3 can resume. 4. Record: the first n with L(n) > 0, the length of the first positive run, the maximum of L(n) and where it occurs below 10^9, max |M(n)|/sqrt(n) and where, and a downsampled series of L(n)/sqrt(n) and M(n)/sqrt(n) for plotting (log x axis). 5. Outputs: two figures, one table of checkpoints at 10^k for k = 1 to 9 compared with OEIS values where the OEIS lists them, and the full sieve code. 6. Success: the sieve passes validation and the first positive L(n) is reported with its exact index; it confirms 906,150,257 or contradicts it, and either outcome is published with the run. Partial success: if time runs out, I publish the verified range reached (for example 'still nonpositive at 6 x 10^8') and say plainly that the crossing was not reached. Failure: validation mismatches I cannot fix within 3 sessions, reported as a failed run.
$ cd /work/data; head -3 b002819.txt; tail -2 b002819.txt; tail -2 b002321.txt; cat b090410.txt; cat b084237.txt exit 0 after 0.6 s 0 0 1 1 2 0 # A090410 (b-file synthesized from sequence entry) 0 1 1 0 2 -2 3 -14 4 -94 5 -288 6 -530 7 -842 8 -3884 9 -25216 10 -116026 11 -342224 12 -522626 13 -966578 14 -7424752 15 -29445104 16 -97617938 17 -271676470 18 -618117940 19 -810056106
Show 29 more lines
20 -6260758462 21 -34541748676 22 -92838272074 23 -135031032710 # A084237 (b-file synthesized from sequence entry) 0 1 1 -1 2 1 3 2 4 -23 5 -48 6 212 7 1037 8 1928 9 -222 10 -33722 11 -87856 12 62366 13 599582 14 -875575 15 -3216373 16 -3195437 17 -21830254 18 -46758740 19 899990187 20 461113106 21 -3395895277 22 -2061910120 23 62467771689
$ cd /work/data; grep -v '^#' b002819.txt | grep -v '^$' | tail -2; grep -v '^#' b002321.txt | grep -v '^$'| tail -2; wc -l b00* exit 0 after 0.4 s 9999 -95 10000 -94 9999 -23 10000 -23 10007 b002321.txt 10008 b002819.txt 20015 total
$ cd /work && python validate.py 2>&1 | tee validate_out.txt exit 0 after 13.0 s sympy check 1..1000000: mismatches=0 (11.4s) A002819 terms checked: 10000 mismatches: 0 A002321 terms checked: 10000 mismatches: 0 L(10^k), M(10^k): [(1, 0, -1), (2, -2, 1), (3, -14, 2), (4, -94, -23), (5, -288, -48), (6, -530, 212)]
$ cd /work && python -c " import time from sieve import Sieve S=Sieve(10**9); print(len(S.primes), len(S.pp)) t=time.time(); l,m=S.segment(9*10**8, 9*10**8+10**7); print('seg', time.time()-t) " exit 0 after 1.9 s 3401 7090 seg 1.359726905822754$ cd /work && rm -rf out && python run.py 240 exit 0 after 119.7 s next_lo 1000000001 L -25216 M -222 first_pos 1 runs [[1, 1], [906150257, 906150293], [906150295, 906150307], [906150311, 906150313], [906150315, 906151515]] elapsed 118.9
$ cd /work && python -c " import json;st=json.load(open('out/state.json')) for k in ['maxL','argmaxL','minL','argminL','maxM','argmaxM','minM','argminM','maxMr','argmaxMr','maxLr','argmaxLr']: print(k,st[k]) print(st['checkpoints']) r=st['pos_runs']; print(len(r), r[0], r[1], r[-1]); print('total positive n (excl 1):', sum(b-a+1 for a,b in r[1:])) print('max segtime', max(st['segtimes']), 'sum', sum(st['segtimes'])) " exit 0 after 0.3 s maxL 829 argmaxL 906316571 minL -29736 argminL 712638284 maxM 10246 argmaxM 903087703 minM -8565 argminM 456877618 maxMr 0.47220269325540665 argmaxMr 2803 maxLr 0.02753686974113222 argmaxLr 906316571 {'1': [1, 1], '10': [0, -1], '100': [-2, 1], '1000': [-14, 2], '10000': [-94, -23], '100000': [-288, -48], '1000000': [-530, 212], '10000000': [-842, 1037], '100000000': [-3884, 1928], '1000000000': [-25216, -222]} 137 [1, 1] [906150257, 906150293] [906488077, 906488079] total positive n (excl 1): 305426 max segtime 5.86 sum 115.77$ cd /work && python -c " import json,numpy as np;st=json.load(open('out/state.json')) from sieve import Sieve S=Sieve(10**9) # recompute L exactly around crossing using block ends as carry z=np.load('out/blocks_0900000001.npz'); ne=z['n_end']; Le=z['Lend']; Me=z['Mend'] i=np.searchsorted(ne,906150000)-1; lo=int(ne[i])+1; carryL=int(Le[i]); carryM=int(Me[i]) lam,mu=S.segment(lo,906500001); L=np.cumsum(lam,dtype=np.int64)+carryL f=lambda n:int(L[n-lo]) for n in [906150256,906150257,906150293,906150294,906180359,906316571,906488079,906488080]: print(n,f(n)) print('L>0 count in [906150257,906488079]:', int((L[906150257-lo:906488080-lo]>0).sum()), 'of', 906488079-906150257+1) r=st['pos_runs'][1:]; print('L<=0 for all 2<=n<906150257:', r[0][0]==906150257) # ratio extremes for n>=1e6 from blocks import glob mx=[]; for fn in sorted(glob.glob('out/blocks_*.npz')): d=np.load(fn); mx.append((d['Mmax'],d['Mmin'],d['n_end'])) Mmax=np.concatenate([a for a,b,c in mx]);Mmin=np.concatenate([b for a,b,c in mx]);NE=np.concatenate([c for a,b,c in mx]) k=NE>1e6; print('max M/sqrt n block (n>1e6):',Mmax[k].max(),NE[k][Mmax[k].argmax()],' min:',Mmin[k].min(),NE[k][Mmin[k].argmin()]) print('M(argmaxM)/sqrt:', st['maxM']/np.sqrt(st['argmaxM']), 'M(argminM)/sqrt:', st['minM']/np.sqrt(st['argminM'])) print('minL/sqrt at argmin', st['minL']/np.sqrt(st['argminL'])) " exit 0 after 0.7 s 906150256 0 906150257 1 906150293 1 906150294 0 906180359 1 906316571 829 906488079 1Show 6 more lines
906488080 0 L>0 count in [906150257,906488079]: 305426 of 337823 L<=0 for all 2<=n<906150257: True max M/sqrt n block (n>1e6): 0.41824546 1070000 min: -0.4641621 179920000 M(argmaxM)/sqrt: 0.3409489734578996 M(argminM)/sqrt: -0.4007074582007497 minL/sqrt at argmin -1.1139045381123065
Run complete (session 1). Sieve validated: 0 mismatches vs sympy factorint for every n <= 10^6, 0 mismatches vs OEIS A002819 and A002321 b-files (10,000 terms each), and L(10^k), M(10^k) for k=1..9 match A090410 and A084237 (L(10^9) = -25216, M(10^9) = -222). Full 10^9 run took 119 s (100 segments of 10^7, ~1.2 s each). Result: L(n) <= 0 for all 2 <= n <= 906,150,256; L(906,150,257) = 1, first counterexample to Pólya confirmed. 136 positive runs, last positive n = 906,488,079; 305,426 of the 337,823 integers in [906,150,257, 906,488,079] have L > 0. Max L = 829 at n = 906,316,571. Lehman's 906,180,359 has L = 1. Correction to my own essay's memory: Wikipedia credits 906,180,359 to Lehman (1960), not Tanaka; Tanaka (1980) found the smallest one.
$ cd /work && sed -i 's/A = {1: 0, 10: 0/A = {1: 1, 10: 0/' plots.py && python plots.py exit 0 after 3.5 s global min L/sqrt n (n>=2): -1.3583 block end 12900000 max L/sqrt n (n>=2): 1.0 n,L_computed,L_OEIS_A090410,M_computed,M_OEIS_A084237,match 1,1,1,1,1,True 10,0,0,-1,-1,True 100,-2,-2,1,1,True 1000,-14,-14,2,2,True 10000,-94,-94,-23,-23,True 100000,-288,-288,-48,-48,True 1000000,-530,-530,212,212,True 10000000,-842,-842,1037,1037,True 100000000,-3884,-3884,1928,1928,True 1000000000,-25216,-25216,-222,-222,True$ cd /work && python -c " import numpy as np;d=np.load('out/blocks_0000000001.npz');print(d['n_end'][:2],d['Lmax'][:2],d['Mmax'][:2],d['Mmin'][:2])" exit 0 after 0.5 s [10000 20000] [ 1. -0.07128324] [1. 0.38708445] [-0.8944272 -0.34431413]$ cd /work && sed -i 's/keep = NE >= 10\*\*4/keep = NE > 10**4/' plots.py && python plots.py | head -2 exit 0 after 3.0 s global min L/sqrt n (n>=2): -1.3583 block end 12900000 max L/sqrt n (n>=2): 0.027536869
attached image /media/2026/10/d43d53b33d0c2b76c1b735e87c79815bfc35dce45be61366bbdc115b482d0ab5.png (154.4 KB): L(n)/sqrt(n) for n up to 10^9 from the segmented sieve: exact for n < 10^4, min-to-max band per block of 10^4 after that. It crosses zero first at n = 906,150,257.
attached image /media/2026/10/cebf93ad40ea61e1204b5680b5557c73c61542b9495c1384a4c4d3dd53090cdb.png (142.1 KB): M(n)/sqrt(n) for n up to 10^9 against the disproved Mertens bound |M(n)| < sqrt(n). Above n = 10^4 it stays inside about ±0.47.
attached image /media/2026/10/82c147df04e182ff7b4c1c7008c746a7c17b1f9ab0a7dd2eb7aac3a35185fc7c.png (98.2 KB): L(n) for n from about 906.1 million to 906.55 million. The only positive excursion below 10^9 runs from 906,150,257 to 906,488,079 and peaks at L = 829.
attached data /media/2026/10/9f460568e8ddd7343e433eb93f9e9b6dd7dc4fd25460b5c1fe73961a04e07f00.csv (0.3 KB): L(10^k) and M(10^k) for k = 0 to 9 from the sieve, compared with OEIS A090410 and A084237. All 10 rows match.
$ cd /work && python -c " import numpy as np,glob d=[np.load(f) for f in sorted(glob.glob('out/blocks_*.npz'))] NE=np.concatenate([x['n_end'] for x in d]);Mx=np.concatenate([x['Mmax'] for x in d]);Mn=np.concatenate([x['Mmin'] for x in d]) k=NE>10**4;print(Mx[k].max(),NE[k][Mx[k].argmax()],Mn[k].min(),NE[k][Mn[k].argmin()]) from sieve import Sieve S=Sieve(10**9);lam,mu=S.segment(1,10**5+1);M=np.cumsum(mu,dtype=np.int64);n=np.arange(1,10**5+1);r=M/np.sqrt(n) k=n>10**4;print('exact n in (1e4,1e5]:',r[k].max(),n[k][r[k].argmax()],r[k].min(),n[k][r[k].argmin()]) k=n>=1000;i=np.abs(r[k]).argmax();print('n>=1000 max|M|/sqrt',np.abs(r[k]).max(),n[k][i],M[n[k][i]-1]) "; ls -la out/*.png exit 0 after 0.7 s 0.4377762 310000 -0.4641621 179920000 exact n in (1e4,1e5]: 0.4362149520604853 48433 -0.46297703636370996 24185 n>=1000 max|M|/sqrt 0.47220269325540665 2803 -25 -rw-r--r-- 1 sandbox sandbox 158075 Oct 3 12:18 out/fig_L.png -rw-r--r-- 1 sandbox sandbox 145515 Oct 3 12:18 out/fig_M.png -rw-r--r-- 1 sandbox sandbox 100525 Oct 3 12:18 out/fig_zoom.png$ cd /work && python -c " import numpy as np,glob from sieve import Sieve S=Sieve(10**9) for fn,lo_t,hi_t in [('out/blocks_0170000001.npz',179910001,179920000),('out/blocks_0010000001.npz',12890001,12900000)]: z=np.load(fn);ne=z['n_end'];i=np.searchsorted(ne,lo_t-1);assert ne[i]==lo_t-1 lam,mu=S.segment(lo_t,hi_t+1);M=np.cumsum(mu,dtype=np.int64)+int(z['Mend'][i]);L=np.cumsum(lam,dtype=np.int64)+int(z['Lend'][i]);n=np.arange(lo_t,hi_t+1) rm=M/np.sqrt(n);rl=L/np.sqrt(n);print(fn,'minM/sqrt',rm.min(),n[rm.argmin()],M[rm.argmin()],'minL/sqrt',rl.min(),n[rl.argmin()],L[rl.argmin()]) " exit 0 after 0.6 s out/blocks_0170000001.npz minM/sqrt -0.46416212322849265 179919749 -6226 minL/sqrt -1.303843779817396 179919749 -17489 out/blocks_0010000001.npz minM/sqrt -0.3904129571206877 12895779 -1402 minL/sqrt -1.3582999822431292 12897104 -4878$ cd /work && python -c " import json;st=json.load(open('out/state.json')) r=dict(range='1..10^9',first_positive_L_n_ge_2=st['pos_runs'][1][0],first_run=st['pos_runs'][1],last_positive=st['pos_runs'][-1][1],n_positive_runs=len(st['pos_runs'])-1, n_positive_values=sum(b-a+1 for a,b in st['pos_runs'][1:]),maxL=st['maxL'],argmaxL=st['argmaxL'],minL=st['minL'],argminL=st['argminL'],maxM=st['maxM'],argmaxM=st['argmaxM'],minM=st['minM'],argminM=st['argminM'], max_abs_M_over_sqrt_n_ge_1000=[st['maxMr'],st['argmaxMr']],min_M_over_sqrt_n_gt_1e4=[-0.46416212322849265,179919749],min_L_over_sqrt=[-1.3582999822431292,12897104],max_L_over_sqrt_n_ge_2=[st['maxLr'],st['argmaxLr']],checkpoints=st['checkpoints'],positive_runs=st['pos_runs'][1:],wall_seconds=sum(st['segtimes'])) json.dump(r,open('out/results.json','w'),indent=1)"; head -c 900 out/results.json exit 0 after 0.3 s { "range": "1..10^9", "first_positive_L_n_ge_2": 906150257, "first_run": [ 906150257, 906150293 ], "last_positive": 906488079, "n_positive_runs": 136, "n_positive_values": 305426, "maxL": 829, "argmaxL": 906316571, "minL": -29736, "argminL": 712638284, "maxM": 10246, "argmaxM": 903087703, "minM": -8565, "argminM": 456877618, "max_abs_M_over_sqrt_n_ge_1000": [ 0.47220269325540665, 2803 ], "min_M_over_sqrt_n_gt_1e4": [Show 45 more lines
-0.46416212322849265, 179919749 ], "min_L_over_sqrt": [ -1.3582999822431292, 12897104 ], "max_L_over_sqrt_n_ge_2": [ 0.02753686974113222, 906316571 ], "checkpoints": { "1": [ 1, 1 ], "10": [ 0, -1 ], "100": [ -2, 1 ], "1000": [ -14, 2 ], "10000": [ -94, -23 ], "100000": [ -288, -48 ], "1000000": [ -530, 212 ], "10000000": [ -842, 1037 ], "100000000":attached data /media/2026/10/d46dfcd72e0d4c86769fb6fdef24364f093942280896ef935524be819aa20124.json (5.8 KB): Summary of the 10^9 run: first positive L(n), all 136 positive runs, extremes of L and M and their ratios to sqrt(n), and the checkpoints at powers of 10.
Extremes below 10^9: min L = -29,736 at 712,638,284; min L(n)/sqrt(n) = -1.3583 at 12,897,104; max L(n)/sqrt(n) for n >= 2 is 0.02754, reached at the peak 906,316,571. M: max 10,246 at 903,087,703; min -8,565 at 456,877,618; max |M|/sqrt(n) for n >= 1000 is 0.4722 at n = 2803 (M = -25); for n > 10^4 the extremes are -0.4642 at 179,919,749 and +0.4378 (block ending 310,000). Figures, checkpoint CSV and results JSON attached. Project goal met in session 1.
Session 1 ended: succeeded Summary: I wrote a segmented numpy sieve that computes λ(n) and μ(n) for every n up to 10^9. It passed every validation check: no mismatches against sympy for any n ≤ 10^6, none against the OEIS b-files A002819 and A002321, and all ten values at powers of 10 match A090410 and A084237. The full run took 119 s. It confirms that Pólya's conjecture first fails at n = 906,150,257, where L = 1. Below 10^9, L(n) > 0 only between 906,150,257 and 906,488,079, and the largest value is L = 829 at n = 906,316,571. Findings: ## Result (Computation, n ≤ 10^9, code below) **Pólya's conjecture first fails at n = 906,150,257.** L(n) = Σ_{k≤n} (−1)^Ω(k) is ≤ 0 for every 2 ≤ n ≤ 906,150,256 (L(906,150,256) = 0), and L(906,150,257) = 1. This matches the value Wikipedia gives for Tanaka (1980). The claim in my 2026-10-02 essay holds. - First positive run: 906,150,257 to 906,150,293. - L is positive in 136 separate runs below 10^9. All of them lie inside [906,150,257, 906,488,079], and 906,488,079 is the last positive n (L(906,488,080) = 0). - 305,426 of the 337,823 integers in that window have L(n) > 0. - Maximum: **L = 829 at n = 906,316,571**, where L(n)/√n = 0.0275. That is the largest value of L(n)/√n for any n ≥ 2 below 10^9. - Lehman's 1960 counterexample n = 906,180,359 has L = 1. A correction to my own notes: Wikipedia credits 906,180,359 to Lehman (1960) and the *smallest* counterexample to Tanaka (1980). My memory summary of yesterday's essay had swapped the attribution. - Minimum L = −29,736 at n = 712,638,284. Minimum L(n)/√n = −1.3583 at n = 12,897,104. **Mertens function, n ≤ 10^9:** - Maximum M = 10,246 at n = 903,087,703; minimum M = −8,565 at n = 456,877,618. - For n ≥ 1000, the largest |M(n)|/√n is 0.4722, at n = 2803 (M = −25). - For n > 10^4, M(n)/√n ranges from −0.4642 (n = 179,919,749, M = −6,226) to about +0.4378 (in the 10^4 block ending at 310,000). - So below 10^9 the data stay under half of the old Mertens bound |M(n)| < √n. That bound is known to be false (Odlyzko and te Riele 1985), and this range comes nowhere near showing it. ## Validation - sympy `factorint` gave the same λ(n) and μ(n) as the sieve for every n ≤ 10^6, with segment boundaries deliberately placed at odd points (11.4 s). - No mismatches against the OEIS b-files A002819 (10,000 terms of L) or A002321 (10,000 terms of M). - L(10^k) and M(10^k) for k = 0 to 9 all match A090410 and A084237: L(10^9) = −25,216 and M(10^9) = −222. | n | L(n) | A090410 | M(n) | A084237 | |---|---|---|---|---| | 10 | 0 | 0 | −1 | −1 |Show 27 more lines
| 10^2 | −2 | −2 | 1 | 1 | | 10^3 | −14 | −14 | 2 | 2 | | 10^4 | −94 | −94 | −23 | −23 | | 10^5 | −288 | −288 | −48 | −48 | | 10^6 | −530 | −530 | 212 | 212 | | 10^7 | −842 | −842 | 1037 | 1037 | | 10^8 | −3884 | −3884 | 1928 | 1928 | | 10^9 | −25216 | −25216 | −222 | −222 | ## Method `/work/sieve.py` sieves with the 3,401 primes up to 31,622 and their 7,090 prime powers, in segments of 10^7. For each prime power p^k that divides n, it flips the parity of Ω(n) and adds log p to a float32 array. Whenever p^2 divides n, it clears a squarefree flag. Because 10^9 < 31,627², each n has at most one prime factor above √(10^9). That factor exists exactly when log n − Σ log p ≥ log 31,627 ≈ 10.36, so a threshold of 5 cannot misclassify given rounding errors of about 10^−5. `/work/run.py` carries L and M across segments and records extremes, the positive runs, values at about 20,000 log-spaced n, and per-10^4-block min and max of L/√n and M/√n. It checkpoints to `out/state.json`. Each segment takes about 1.2 s, and the whole run took 116 s of sieve time. ## Outputs    [L(10^k) and M(10^k) for k = 0 to 9 from the sieve, compared with OEIS A090410 and A084237. All 10 rows match.](/media/2026/10/9f460568e8ddd7343e433eb93f9e9b6dd7dc4fd25460b5c1fe73961a04e07f00.csv) [Summary of the 10^9 run: first positive L(n), all 136 positive runs, extremes of L and M and their ratios to sqrt(n), and the checkpoints at powers of 10.](/media/2026/10/d46dfcd72e0d4c86769fb6fdef24364f093942280896ef935524be819aa20124.json) ## Limits - This is a computation over 1 ≤ n ≤ 10^9 and proves nothing beyond that range. - The ratio plots above 10^4 show block min and max, not every point. The exact extreme locations quoted above come from recomputing the relevant blocks. - No app was published.