| … | … | @@ -7,6 +7,26 @@ |
| 7 | 7 | * 0 PARASITES, which is death, not collapse-to-parasites. Units now persist, production adds, and a |
| 8 | 8 | * per-unit death rate removes. |
| 9 | 9 | * |
| 10 | * FOURTH ATTEMPT — fluctuating environment. NOT void (T0 passed, arms differ), but the |
| 11 | * PRE-REGISTERED METRIC WAS WRONG, and wrong in a way already documented in genome.md. |
| 12 | * |
| 13 | * arm | templates | working | function |
| 14 | * STATIC, full | 0.007 | 0.940 | 2.41 |
| 15 | * FLUCTUATING every 40 | 0.013 | 0.924 | 2.28 |
| 16 | * FLUCTUATING every 15 | 0.012 | 0.478 | 1.47 |
| 17 | * FLUCTUATING 15, reading OFF | 0.023 | 0.294 | 1.27 |
| 18 | * |
| 19 | * M1/M2 were both scored on TEMPLATE ABUNDANCE. That is the wrong variable: reading CONSUMES |
| 20 | * templates by converting them into catalysts, so the reading-OFF arm holds MORE of them (0.023 vs |
| 21 | * 0.012) precisely because they are useless there. Template count measures templates NOT BEING USED. |
| 22 | * genome.md records this exact mistake; this is the third time in one session it has been made. |
| 23 | * |
| 24 | * ON THE RIGHT VARIABLE the effect is present: under fluctuation, turning reading ON raises the |
| 25 | * working fraction 0.294 -> 0.478 and function 1.27 -> 1.47. Templates are being USED and it helps. |
| 26 | * That is suggestive, not established: it was not the pre-registered test, n=5 seeds, and it needs a |
| 27 | * clean re-run scored on function with its own control before it can be claimed. |
| 28 | * |
| 29 | * ---- third attempt ---- |
| 10 | 30 | * THIRD ATTEMPT, ALSO VOID — and it refines the diagnosis rather than fixing it. |
| 11 | 31 | * The payoff was made EXPENSIVE TO REDISCOVER (NTARG=4 SPECIFIC types out of NTYPE=16, so a lost |
| 12 | 32 | * type costs many mutations to re-find instead of one in four). Templates STILL collapse: |
| … | … | @@ -163,10 +183,19 @@ static int func_of(int c){ |
| 163 | 183 | } |
| 164 | 184 | |
| 165 | 185 | /* ko: 0 = FULL, 1 = boundary decoupled, 2 = reading off, 3 = replicase off */ |
| 166 | | static void run(int ko,double *alive,double *funcavg,double *parfrac) |
| 167 | | { |
| 186 | static void retarget(void){ |
| 168 | 187 | for(int t=0;t<NTYPE;t++) TARGET[t]=0; |
| 169 | 188 | for(int got=0;got<NTARG;){ int t=rint_(NTYPE); if(!TARGET[t]){ TARGET[t]=1; got++; } } |
| 189 | } |
| 190 | /* switch_every = 0 means a STATIC environment (the previous condition). Otherwise the target set is |
| 191 | redrawn every switch_every generations: a type not needed now becomes needed later, so holding one |
| 192 | in a template pays REGULARLY rather than only if something is lost. That converts the deferred, |
| 193 | conditional benefit into a recurring one WITHOUT requiring small compartments — which is the |
| 194 | constraint fidfloor.c placed on any fix. */ |
| 195 | static int SWITCH_EVERY=0; |
| 196 | static void run(int ko,double *alive,double *funcavg,double *parfrac) |
| 197 | { |
| 198 | retarget(); |
| 170 | 199 | ncomp=NCOMP; |
| 171 | 200 | for(int c=0;c<ncomp;c++){ |
| 172 | 201 | sz[c]=CAP; mat[c]=0; |
| … | … | @@ -179,6 +208,7 @@ static void run(int ko,double *alive,double *funcavg,double *parfrac) |
| 179 | 208 | } |
| 180 | 209 | } |
| 181 | 210 | for(int g=0;g<GEN;g++){ |
| 211 | if(SWITCH_EVERY>0 && g>0 && g%SWITCH_EVERY==0) retarget(); |
| 182 | 212 | for(int c=0;c<ncomp;c++){ |
| 183 | 213 | int nc,nt,np; counts(c,&nc,&nt,&np); |
| 184 | 214 | /* coupling 1: metabolism -> boundary. K1 decouples it. */ |
| … | … | @@ -247,56 +277,59 @@ int main(void) |
| 247 | 277 | unsigned long long seeds[5]={0x9e3779b97f4a7c15ULL,0xd1b54a32d192ed03ULL,0x2545f4914f6cdd1dULL, |
| 248 | 278 | 0x123456789abcdefULL,0xfeedface12345678ULL}; |
| 249 | 279 | int NS=5; |
| 250 | | printf("=== THREE CARRIERS: is the COMPLETE system STABLE? (not: can it bootstrap) ===\n"); |
| 251 | | printf(" BOUNDARY nobody maintains, METABOLISM that produces, TEMPLATE that only remembers —\n"); |
| 252 | | printf(" PAYOFF IS NOW EXPENSIVE TO REDISCOVER: %d SPECIFIC types of %d, so a lost type costs many\n mutations to re-find and a template holding one is worth keeping.\n",NTARG,NTYPE); |
| 253 | | printf(" three couplings, none defectable: metabolism->boundary, template->function,\n"); |
| 254 | | printf(" catalyst->template fidelity. Seeded COMPLETE; parasites are NOT seeded, they arise by\n"); |
| 255 | | printf(" mutation, replicate %.0fx faster and contribute nothing. %d compartments x %d, %d gens.\n\n",1+BETA,NCOMP,CAP,GEN); |
| 256 | | printf(" arm | working (func>=2) | mean function (max %d) | templates | parasites\n",NTARG); |
| 257 | | printf(" ------------------------+-------------------+------------------------+-----------+----------\n"); |
| 258 | | const char *nm[4]={"FULL (all three) ","K1 boundary decoupled ","K2 reading off ","K3 replicase off "}; |
| 259 | | double A[4],F[4],P[4],T[4]; |
| 280 | printf("=== FLUCTUATING ENVIRONMENT: can memory pay when what is needed CHANGES? ===\n"); |
| 281 | printf(" Three void attempts established the obstacle: a template costs a slot NOW while selection\n"); |
| 282 | printf(" scores current function EVERY generation, so a deferred, conditional benefit is lost\n"); |
| 283 | printf(" before it can be won. Making rediscovery expensive raised the later payoff without\n"); |
| 284 | printf(" touching the immediate cost, and the obvious remedy (frequent losses => small\n"); |
| 285 | printf(" compartments) collides with fidfloor.c.\n"); |
| 286 | printf(" THE FIX UNDER TEST: let the target set CHANGE. A type not needed now becomes needed\n"); |
| 287 | printf(" later, so holding one in a template pays REGULARLY rather than conditionally — and it\n"); |
| 288 | printf(" needs no small compartments. %d of %d types needed at a time.\n\n",NTARG,NTYPE); |
| 289 | |
| 290 | printf(" arm | templates | working | mean function (max %d) | parasites\n",NTARG); |
| 291 | printf(" -----------------------------+-----------+---------+------------------------+----------\n"); |
| 292 | struct { const char*nm; int ko,sw; } arms[4]={ |
| 293 | {"STATIC, full couplings ",0,0}, |
| 294 | {"FLUCTUATING every 40 ",0,40}, |
| 295 | {"FLUCTUATING every 15 ",0,15}, |
| 296 | {"FLUCTUATING 15, reading OFF ",2,15}}; |
| 297 | double T[4],A[4],F[4],P[4]; |
| 260 | 298 | for(int k=0;k<4;k++){ |
| 261 | 299 | double a=0,f=0,p=0,tf=0; |
| 262 | | for(int s=0;s<NS;s++){ double x,y,z; RNG=seeds[s]; run(k,&x,&y,&z); a+=x; f+=y; p+=z; tf+=TFRAC; } |
| 263 | | A[k]=a/NS; F[k]=f/NS; P[k]=p/NS; T[k]=tf/NS; |
| 264 | | printf(" %s | %.3f | %.2f | %.3f | %.3f\n",nm[k],A[k],F[k],T[k],P[k]); |
| 300 | for(int s=0;s<NS;s++){ |
| 301 | double x,y,z; RNG=seeds[s]; SWITCH_EVERY=arms[k].sw; |
| 302 | run(arms[k].ko,&x,&y,&z); a+=x; f+=y; p+=z; tf+=TFRAC; |
| 303 | } |
| 304 | A[k]=a/NS;F[k]=f/NS;P[k]=p/NS;T[k]=tf/NS; |
| 305 | printf(" %s | %.3f | %.3f | %.2f | %.3f\n",arms[k].nm,T[k],A[k],F[k],P[k]); |
| 265 | 306 | } |
| 266 | 307 | printf("\n"); |
| 267 | | int t3 = P[0]>0.01 || P[1]>0.01 || P[2]>0.01 || P[3]>0.01; |
| 268 | | int t1 = A[0]>0.5; |
| 269 | | int ko_collapse=0; for(int k=1;k<4;k++) if(A[k] < A[0]-0.15) ko_collapse++; |
| 270 | | int arms_differ=0; for(int k=1;k<4;k++) if(fabs(A[k]-A[0])>0.03||fabs(F[k]-F[0])>0.10) arms_differ=1; |
| 271 | | printf(" T3 parasites arose and could win : %s (max frac %.3f)\n", t3?"YES":"NO — nothing was resisted", |
| 272 | | fmax(fmax(P[0],P[1]),fmax(P[2],P[3]))); |
| 273 | | printf(" T1 FULL persists : %s (%.3f intact)\n", t1?"YES":"NO",A[0]); |
| 274 | | printf(" T2 knockouts collapse : %d of 3\n",ko_collapse); |
| 275 | | printf(" T0 arms actually differ at all : %s\n\n", arms_differ?"YES":"NO — the ablations are not ablating, result void"); |
| 308 | int mem_pays = (T[1]>T[0]+0.03) || (T[2]>T[0]+0.03); |
| 309 | int needs_read= (T[2]>T[3]+0.02); |
| 310 | int differ = mem_pays || fabs(F[2]-F[0])>0.10; |
| 311 | printf(" M1 templates persist better when the environment fluctuates : %s (%.3f/%.3f vs static %.3f)\n", |
| 312 | mem_pays?"YES":"no",T[1],T[2],T[0]); |
| 313 | printf(" M2 and that depends on templates being READABLE : %s (%.3f vs %.3f)\n", |
| 314 | needs_read?"YES":"no",T[2],T[3]); |
| 315 | printf(" T0 arms differ at all : %s\n\n", differ?"YES":"NO — result void"); |
| 276 | 316 | |
| 277 | | if(!arms_differ) |
| 278 | | printf(" => VOID. The arms are indistinguishable, so at least one ablation is not ablating.\n" |
| 279 | | " Nothing here bears on stability. Fix the knockouts before reading anything.\n"); |
| 280 | | else if(!t3) |
| 281 | | printf(" => TEST DID NOT RUN. Parasites never appeared, so nothing was being resisted and\n" |
| 282 | | " persistence means nothing. Invalid, not a result.\n"); |
| 283 | | else if(t1 && ko_collapse==3) |
| 284 | | printf(" => THE COMPLETE SYSTEM IS STABLE, AND ALL THREE COUPLINGS ARE LOAD-BEARING. It holds\n" |
| 285 | | " against parasites when whole and collapses when ANY single coupling is cut. That is\n" |
| 286 | | " the simultaneous-origin claim measured rather than asserted: the arc's failures were\n" |
| 287 | | " all attempts to get two carriers and derive the third, and this says the third\n" |
| 288 | | " cannot be derived because the system is only stable complete.\n"); |
| 289 | | else if(t1 && ko_collapse>0) |
| 290 | | printf(" => STABLE, BUT ONLY %d OF 3 COUPLINGS ARE LOAD-BEARING. The others can be cut without\n" |
| 291 | | " collapse, so the system is over-specified — report which, it narrows what a\n" |
| 292 | | " minimal origin actually needs.\n",ko_collapse); |
| 293 | | else if(t1) |
| 294 | | printf(" => STABLE, AND NO COUPLING IS LOAD-BEARING. Persistence does not depend on any of the\n" |
| 295 | | " three, so something else is holding it up. Find that before claiming anything.\n"); |
| 317 | if(!differ) |
| 318 | printf(" => VOID AGAIN. Fluctuation changes nothing measurable, so the fourth diagnosis is also\n" |
| 319 | " wrong or the model still cannot express the benefit. Do not patch a fifth time\n" |
| 320 | " without a different design.\n"); |
| 321 | else if(mem_pays && needs_read) |
| 322 | printf(" => MEMORY PAYS WHEN THE WORLD CHANGES. Templates persist under fluctuation and not\n" |
| 323 | " under a fixed target, and the effect disappears when they cannot be read — so it is\n" |
| 324 | " the INFORMATION being used, not the slot being occupied. The third carrier finally\n" |
| 325 | " has a reason to exist, and it needed no small compartments, so it does not collide\n" |
| 326 | " with fidfloor.c. This is a condition on the ENVIRONMENT, not on the chemistry.\n"); |
| 327 | else if(mem_pays) |
| 328 | printf(" => TEMPLATES PERSIST, BUT NOT BECAUSE THEY ARE READ (%.3f vs %.3f with reading off).\n" |
| 329 | " Something other than the information is retaining them. Claim nothing yet.\n",T[2],T[3]); |
| 296 | 330 | else |
| 297 | | printf(" => THE COMPLETE SYSTEM IS NOT STABLE. Even seeded whole, with all three couplings\n" |
| 298 | | " intact, it collapses to parasites. That is a stronger negative than anything the arc\n" |
| 299 | | " has produced: it is not that 1->2 cannot be REACHED, it is that the destination does\n" |
| 300 | | " not hold together under its own tragedy.\n"); |
| 331 | printf(" => HONEST NULL. Fluctuation does not rescue memory: templates stay at %.3f vs %.3f\n" |
| 332 | " static. A deferred benefit made recurring is still not enough, and the obstacle is\n" |
| 333 | " deeper than the timing of the payoff.\n",T[2],T[0]); |
| 301 | 334 | return 0; |
| 302 | 335 | } |