Datasets:
Formats:
json
Languages:
English
Size:
1K - 10K
Tags:
matter-embryogenesis
developmental-fabrication
nanotechnology
self-assembly
materials-science
passive-networks
| """Coarse stochastic lattice demonstrator with finite-volume transport. | |
| Not molecular dynamics, not a validated kTAM, and not proof of a finite chemical alphabet. | |
| The same grammar is evaluated locally from inherited counters. Instruction copying is | |
| ideal except in the explicitly labelled common-mode ablation. Lattice sites represent | |
| porous computational modules. Maintained feed planes are an EXTERNAL apparatus resource. | |
| """ | |
| from dataclasses import dataclass, asdict | |
| import numpy as np | |
| from genome import evaluate, canonical | |
| class Config: | |
| n:int=16 | |
| dim:int=3 | |
| dt:float=0.1 | |
| steps:int=700 | |
| diffusivity:float=0.35 # lattice pitch^2 / abstract time | |
| attachment:float=3.0 | |
| birth:float=0.015 | |
| repair:float=0.9 | |
| detection:float=0.96 | |
| repair_error:float=0.02 | |
| initial_error:float=0.12 | |
| transduction_error:float=0.015 | |
| common_mode:float=0. | |
| dwell:float=4. | |
| resource_cost:float=0.06 | |
| maintenance_cost:float=0.10 | |
| channel_spacing:int=5 | |
| hard_permeability:float=0.02 | |
| seed:int=0 | |
| def prior(a, axis, fill=0): | |
| out=np.full_like(a,fill) | |
| dst=[slice(None)]*a.ndim; src=dst.copy() | |
| dst[axis]=slice(1,None); src[axis]=slice(None,-1) | |
| out[tuple(dst)]=a[tuple(src)] | |
| return out | |
| def diffusion_step(c, permeability, D, dt): | |
| """Conservative no-flux faces. Harmonic conductance, positive CFL step.""" | |
| out=c.copy() | |
| for ax in range(c.ndim): | |
| a=[slice(None)]*c.ndim; b=a.copy(); a[ax]=slice(None,-1); b[ax]=slice(1,None) | |
| a,b=tuple(a),tuple(b) | |
| g=2*permeability[a]*permeability[b]/np.maximum(permeability[a]+permeability[b],1e-30) | |
| flux=D*dt*g*(c[b]-c[a]); out[a]+=flux; out[b]-=flux | |
| return out | |
| def simulate(g,cfg): | |
| if 2*cfg.dim*cfg.diffusivity*cfg.dt>1: | |
| raise ValueError('Explicit diffusion CFL violated') | |
| rng=np.random.default_rng(cfg.seed); shape=(cfg.n,)*cfg.dim | |
| # 0 absent, 1 reversible, 2 hardened. Material 0 is sacrificial/void output. | |
| state=np.zeros(shape,np.int8); mat=np.full(shape,-1,np.int8) | |
| intent=np.zeros(shape,np.int8); age=np.zeros(shape); c=np.ones(shape) | |
| coords=np.zeros(shape+(cfg.dim,),np.int32); time0=(0,)*cfg.dim | |
| state[time0]=1; intent[time0]=int(evaluate(g,np.zeros(cfg.dim,dtype=int))) | |
| mat[time0]=intent[time0] | |
| reservoir=np.zeros(shape,bool) | |
| for ax in range(cfg.dim): | |
| sl=[slice(None)]*cfg.dim; sl[ax]=0; reservoir[tuple(sl)]=True | |
| sl[ax]=-1; reservoir[tuple(sl)]=True | |
| if cfg.channel_spacing: | |
| # Fixed externally perfused planes, present at t=0, charged to apparatus. | |
| sl=[slice(None)]*cfg.dim; sl[0]=slice(0,None,cfg.channel_spacing) | |
| reservoir[tuple(sl)]=True | |
| attach_count=1; repair_count=0; repair_attempts=0; fuel_proxy=0. | |
| supply=0.; consumed=0.; waste=0.; trace=[]; post_transduction=0 | |
| for step in range(cfg.steps): | |
| permeability=np.where(state==2,cfg.hard_permeability,1.) | |
| c=diffusion_step(c,permeability,cfg.diffusivity,cfg.dt) | |
| supply+=float(np.sum(1-c[reservoir])); c[reservoir]=1. | |
| before=state.copy(); candidate=np.zeros(shape,bool) | |
| inherited=np.zeros_like(coords) | |
| for ax in range(cfg.dim): | |
| available=(prior(before,ax)>0)&(before==0)&~candidate | |
| pc=prior(coords,ax); pc[...,ax]+=1 | |
| inherited[available]=pc[available]; candidate|=available | |
| # The seed's bound terminates growth even in a larger simulation vessel. | |
| seed_bound=np.all(inherited < g.get('n',cfg.n),axis=-1) | |
| take=candidate&seed_bound&(c>=cfg.resource_cost)&(rng.random(shape)<-np.expm1(-cfg.attachment*c*cfg.dt)) | |
| coords[take]=inherited[take] | |
| if np.any(take): | |
| intent[take]=evaluate(g,coords[take]) | |
| cm=rng.random(np.count_nonzero(take))<cfg.common_mode | |
| # Corrupt both local specification and material: local checking cannot see it. | |
| vals=intent[take]; vals[cm]=(vals[cm]+1)%3; intent[take]=vals | |
| vals=intent[take].copy(); bad=rng.random(len(vals))<cfg.initial_error | |
| vals[bad]=(vals[bad]+rng.integers(1,3,size=np.count_nonzero(bad)))%3 | |
| mat[take]=vals | |
| state[take]=1; c[take]-=cfg.resource_cost | |
| attach_count+=int(take.sum()); consumed+=float(take.sum()*cfg.resource_cost) | |
| soft=state==1 | |
| damage=soft&(rng.random(shape)<-np.expm1(-cfg.birth*cfg.dt)) | |
| mat[damage]=(mat[damage]+rng.integers(1,3,size=damage.sum()))%3 | |
| # Syndrome compared against local specification, not analysis target. | |
| wrong=soft&(mat!=intent) | |
| fix=wrong&(c>=cfg.resource_cost)&(rng.random(shape)<-np.expm1(-cfg.repair*cfg.detection*c*cfg.dt)) | |
| repair_attempts+=int(fix.sum()); failed=fix&(rng.random(shape)<cfg.repair_error) | |
| good=fix&~failed; mat[good]=intent[good] | |
| repair_count+=int(good.sum()); c[fix]-=cfg.resource_cost | |
| consumed+=float(fix.sum()*cfg.resource_cost); waste+=float(fix.sum()*cfg.resource_cost) | |
| # Age is an access/developmental deadline; concentration also controls maturation. | |
| age[soft]+=cfg.dt | |
| lock=soft&(age>=cfg.dwell)&(c>=0.15) | |
| state[lock]=2 | |
| defect=lock&(rng.random(shape)<cfg.transduction_error) | |
| mat[defect]=(mat[defect]+rng.integers(1,3,size=defect.sum()))%3 | |
| post_transduction+=int(defect.sum()) | |
| metabolic=np.minimum(c,cfg.maintenance_cost*cfg.dt*(state==1)) | |
| c-=metabolic; consumed+=float(metabolic.sum()) | |
| fuel_proxy+=float((take.sum()+fix.sum()+lock.sum())*10.) | |
| if step%10==0: | |
| trace.append([step*cfg.dt,int((state>0).sum()),int((state==2).sum()),float(c.min()),repair_count]) | |
| if np.all(state==2): break | |
| # Analysis-only target, constructed after dynamics finish. | |
| analytic_coords=np.moveaxis(np.indices(shape),0,-1) | |
| target=evaluate(g,analytic_coords); final=np.where(state==2,mat,-1) | |
| target_occ=target>0; got_occ=final>0 | |
| intersection=np.logical_and(target_occ,got_occ).sum() | |
| union=np.logical_or(target_occ,got_occ).sum() | |
| errors=final!=target | |
| result={'config':asdict(cfg),'genome':g,'program_bytes':len(canonical(g)), | |
| 'completed_fraction':float((state==2).mean()), 'material_fidelity':float((~errors).mean()), | |
| 'solid_material_fidelity':float(((final==target)&target_occ).sum()/max(1,target_occ.sum())), | |
| 'structural_iou':float(intersection/max(1,union)), 'defect_density':float(errors.mean()), | |
| 'growth_time':float((step+1)*cfg.dt),'repair_attempts':repair_attempts,'successful_repairs':repair_count, | |
| 'repair_overhead':float(repair_attempts/max(1,attach_count)), 'attachment_events':attach_count, | |
| 'transduction_defects':post_transduction,'feed_consumed':consumed,'feed_supplied':supply, | |
| 'waste_proxy':waste,'fuel_turnover_kBT_proxy':fuel_proxy,'min_concentration':float(c.min()), | |
| 'reservoir_site_fraction':float(reservoir.mean()), | |
| 'mass_balance_residual':float(np.prod(shape)+supply-consumed-c.sum()), | |
| 'temporary_counter_bits_per_site':int(cfg.dim*np.ceil(np.log2(cfg.n))), | |
| 'chemical_species_count':None,'implemented_output_labels':3, | |
| 'chemical_species_note':'Not compiled to chemistry; three labels are not three species.', | |
| 'trace':trace} | |
| return result,{'target':target,'final':final,'state':state,'concentration':c,'counters':coords} | |