src/contract_growth.py

"""Reduced stochastic maturation model, complementary to the v1 lattice model.

Each local two-port module contains three parallel branches, each with two
series bonds. A bounded parallel reserve can be deposited in finite increments.
The model has a grown nearest-neighbour service tree, local closure ACKs, a
finite root delivery budget, propagation delay, and an explicit material ledger.

Transport is a conservative batch reservation/delivery model, NOT resolved
fluid dynamics or diffusion. All requested material is delivered within a paid
round time before changes occur. This assumes a routable, nonblocking service
tree with the stated capacity, which must be checked physically. Main text gives
hydraulic/diffusion constraints. No unavailable feedstock is silently consumed.
"""
from dataclasses import dataclass, asdict
import numpy as np
from contracts import conductance, scalar_gate, gaussian_radius
from contract_genome import compile_grid, capsule, canonical, access_from_root, seal_ready


@dataclass
class Config:
    n: int = 8
    dim: int = 2
    max_rounds: int = 48
    initial_bond_error: float = .12
    conversion_bond_error: float = .08
    common_region_scale: float = .65
    common_region_probability: float = .35
    sigma: float = .01
    samples: int = 16
    delta_measure: float = .005
    deposit_increment: float = .045
    deposit_cv: float = .10
    reserve_ratio: float = .9
    growth_material_per_node: float = .1
    bond_material: float = .1
    reserve_bond_factor: float = 4. # two equal series bonds of conductance 2G each
    root_material_rate: float = 2.
    local_reaction_time: float = 1.
    signal_hop_time: float = .03
    seal_actual_bound: float = .01
    seed: int = 0


def module_response(bonds):
    pair = bonds.reshape(-1,3,2)
    return np.sum(pair[:,:,0]*pair[:,:,1]/(pair[:,:,0]+pair[:,:,1]),axis=1)


def delivery_time(node_demand, parent, root_rate, hop_time, depth):
    """Conservative batch schedule: every service edge has a finite capacity.

    Edge capacity is root_rate times its descendant-node fraction. This capacity
    allocation is apparatus design and is charged; it is not obtained free from
    a uniform microscopic tube. Upstream demand summaries use local additions.
    Pipeline startup/ACK propagation is bounded by the maximum path delay.
    """
    subtree=np.asarray(node_demand,float).copy()
    counts=np.ones(len(parent))
    for i in range(len(parent)-1,0,-1):
        subtree[parent[i]]+=subtree[i]; counts[parent[i]]+=counts[i]
    capacity=root_rate*counts/len(parent)
    transfer=float(np.max(subtree/capacity))
    return transfer+hop_time*float(np.max(depth)), transfer


def manufacture(cfg, method='contract'):
    g=capsule(cfg.n,cfg.dim); net=compile_grid(g)
    target=net['target']; owner=net['owner']; edges=net['edges']
    N=len(net['parent']); R=len(target)
    # Separate keyed streams preserve common underlying fabrication draws.
    rng=np.random.default_rng(cfg.seed)
    rng_action=np.random.default_rng(cfg.seed+10000000)
    rng_measure=np.random.default_rng(cfg.seed+20000000)
    nominal=np.repeat((target/1.5)[:,None],6,axis=1)
    reference=nominal.copy()
    regional=np.zeros(R,bool)
    if rng.random()<cfg.common_region_probability:
        # The body's local bond reference is corrupted along with its material.
        regional=net['coordinates'][owner,0]>=cfg.n//2
        reference[regional]*=cfg.common_region_scale
    raw=reference*np.exp(rng.normal(-.025,.025,reference.shape))
    first=rng.random(raw.shape)<cfg.initial_bond_error
    raw[first]*=.15
    blueprint_fixed=first & (rng.random(raw.shape)<.92)
    conversion=rng.random(raw.shape)<cfg.conversion_bond_error
    converted=raw.copy(); converted[conversion]*=.12
    if method=='blueprint':
        soft=raw.copy(); soft[blueprint_fixed]=reference[blueprint_fixed]
        converted=soft; converted[conversion]*=.12
    base=module_response(converted)
    spare=np.zeros(R); accepted=np.zeros(R,bool); sealed=np.zeros(N,bool)
    gain=np.ones(R)
    eta=g['eta']; beta=g['seal_bound']
    radius=gaussian_radius(cfg.sigma,cfg.samples,R,cfg.max_rounds,cfg.delta_measure)
    # Growth is local breadth-first propagation at one lattice edge per unit time.
    # Standard bath/seed material and the generic service tree are explicitly paid.
    scaffold=N*cfg.growth_material_per_node
    base_material=float(np.sum(nominal)*cfg.bond_material)
    supplied=scaffold+base_material
    consumed=supplied; spare_material=0.; discarded_material=0.
    material_at_node=np.full(N,cfg.growth_material_per_node)
    np.add.at(material_at_node,owner,np.sum(nominal,axis=1)*cfg.bond_material)
    grow_time=0.
    for layer in range(int(net['depth'].max())+1):
        demand=np.where(net['depth']==layer,material_at_node,0.)
        service,_=delivery_time(demand,net['parent'],cfg.root_material_rate,
                                cfg.signal_hop_time,np.minimum(net['depth'],layer))
        grow_time+=max(cfg.local_reaction_time,service)
    time=grow_time; inspections=0; deposits=0; closure_violations=0; trace=[]
    blueprint_material=0.
    if method=='blueprint':
        # Charge complete replacement bonds, even though diagnosis is idealized.
        replacement=np.sum(nominal*blueprint_fixed,axis=1)*cfg.bond_material
        blueprint_material=float(replacement.sum())
        supplied+=blueprint_material; consumed+=blueprint_material
        discarded_material=blueprint_material
        demand=np.zeros(N); np.add.at(demand,owner,replacement)
        service,_=delivery_time(demand,net['parent'],cfg.root_material_rate,
                                cfg.signal_hop_time,net['depth'])
        time+=max(cfg.local_reaction_time,service)
    repairable=np.ones(R,bool)
    openloop=method in ('open_loop','blueprint','blind_reserve')
    if method=='blind_reserve':
        spare=.18*target
        spare_material=float(spare.sum()*cfg.bond_material*cfg.reserve_bond_factor)
        supplied+=spare_material; consumed+=spare_material
        demand=np.zeros(N); np.add.at(demand,owner,spare*cfg.bond_material*cfg.reserve_bond_factor)
        service,_=delivery_time(demand,net['parent'],cfg.root_material_rate,
                                cfg.signal_hop_time,net['depth'])
        time+=max(cfg.local_reaction_time,service)
    for round_id in range(cfg.max_rounds):
        access=access_from_root(net['parent'],sealed)
        current=base+spare
        if openloop:
            accepted[:]=True # These baselines make no functional certificate claim.
        else:
            candidates=(~accepted)&access[owner]
            measurement=current/target+rng_measure.normal(0,cfg.sigma/np.sqrt(cfg.samples),R)
            if method=='biased_reference': measurement*=1.07
            inspections+=int(candidates.sum())*cfg.samples
            passed=scalar_gate(measurement,radius,eta,beta)
            accepted|=candidates&passed
            # Sensor-only sees defects but cannot change them.
            need=candidates & ~passed & (measurement<1.)
            if method=='sensor_only': need[:]=False
            possible=need & (spare < cfg.reserve_ratio*target-1e-12)
            delta=cfg.deposit_increment*target*np.clip(1+cfg.deposit_cv*rng_action.normal(size=R),.6,1.4)
            delta=np.minimum(delta,np.maximum(0,cfg.reserve_ratio*target-spare))
            delta[~possible]=0
            requested=float(delta.sum()*cfg.bond_material*cfg.reserve_bond_factor)
            # Access is checked before reserving material. No sealed route supplies it.
            assert np.all(access[owner[possible]])
            supplied+=requested; consumed+=requested; spare_material+=requested
            spare+=delta; deposits+=int(possible.sum())
            repairable=(spare < cfg.reserve_ratio*target-1e-12)
        own_ready=np.ones(N,bool)
        np.logical_and.at(own_ready,owner,accepted)
        previous=sealed.copy()
        # Diagnostic-only may wait forever; this is reported as incomplete.
        sealed=seal_ready(own_ready,sealed,net['children'],method!='early_seal')
        newly=sealed&~previous
        for node in np.flatnonzero(newly):
            if node and any(not previous[ch] for ch in net['children'][node]):
                closure_violations+=1
        affected=newly[owner]
        # The final seal is a distinct physical operation with a declared envelope.
        gain[affected]=rng_action.uniform(1-cfg.seal_actual_bound,1+cfg.seal_actual_bound,int(affected.sum()))
        demand=np.zeros(N)
        if not openloop: np.add.at(demand,owner,delta*cfg.bond_material*cfg.reserve_bond_factor)
        service,_=delivery_time(demand,net['parent'],cfg.root_material_rate,
                                cfg.signal_hop_time,net['depth'])
        time+=max(cfg.local_reaction_time,service)
        trace.append([round_id+1,time,int(accepted.sum()),int(sealed.sum()),float(spare.sum()),int(access.sum())])
        if np.all(sealed): break
    final=(base+spare)*gain
    final_G=conductance(N,edges,final,net['left'],net['right'])
    ideal_G=conductance(N,edges,target,net['left'],net['right'])
    contract_ok=np.abs(final/target-1)<=eta+1e-12
    complete=bool(np.all(sealed))
    cert_method=not openloop
    blocked=(~accepted)&~access_from_root(net['parent'],sealed)[owner]
    response={'config':asdict(cfg),'method':method,'nodes':N,'modules':R,
        'complete':complete,'accepted_fraction':float(accepted.mean()),
        'sealed_fraction':float(sealed.mean()),'local_contract_fraction':float(contract_ok.mean()),
        'all_local_contracts':bool(contract_ok.all()),
        'functional_ratio':final_G/ideal_G,
        'function_ok':bool(abs(final_G/ideal_G-1)<=eta),
        'completed_function_ok':bool(complete and abs(final_G/ideal_G-1)<=eta),
        'false_certificate':bool(cert_method and complete and not contract_ok.all()),
        'growth_time':grow_time,'total_time':time,'maturation_rounds':round_id+1,
        'inspection_samples':inspections,'measurement_radius':radius,
        'deposit_events':deposits,'reserve_used_fraction':float(spare.sum()/(cfg.reserve_ratio*target.sum())) if cfg.reserve_ratio>0 else 0.,
        'nominal_material':base_material,'scaffold_material':scaffold,
        'additional_material':spare_material+blueprint_material,
        'reserve_material':spare_material,'blueprint_replacement_material':blueprint_material,
        'supplied_material':supplied,
        'consumed_material':consumed,'discarded_material':discarded_material,
        'mass_balance_residual':supplied-consumed,
        'blocked_unaccepted_modules':int(blocked.sum()),'closure_violations':closure_violations,
        'common_region_modules':int(regional.sum()),
        'capsule_bytes':len(canonical(g)),'interpreter_is_charged_separately':True,
        'molecular_species_count':None,'trace':trace}
    return response,{'coordinates':net['coordinates'],'edges':edges,'target':target,
                    'base':base,'final':final,'reserve':spare,'sealed':sealed,
                    'accepted':accepted,'parent':net['parent']}