Bonding curves as ALife organisms · deep dive

state_vars = {
    'reserve':      0.0,
    'supply':       0.0,
    'price':        0.0,
    'holders':      set(),
    'gov_events':   [],            # (timestep, proposal_id, accepted)
    'phase_label':  None,          # inferred each block
    'death_cause':  None,          # set once when phase → 'dead'
}
psubs = [
    {'policies':   {'mint_burn':   mint_burn_policy},
     'variables':  {'reserve':     s_reserve,
                    'supply':      s_supply,
                    'price':       s_price}},
    {'policies':   {'phase_clf':   phase_classifier_policy},
     'variables':  {'phase_label': s_phase}},
    {'policies':   {'mortality':   mortality_check_policy},
     'variables':  {'death_cause': s_death}},
]

Phase-label is a derived field updated once per block via phase_classifier_policy. Mortality is checked last so the death cause can reference the final pre-death state.

# shocks injected as exogenous policy actions
shock_schedule = {
    60: ('reserve_drain', {'fraction': 0.35}),
    140: ('holder_exit', {'fraction': 0.4}),
    220: ('gov_attack',  {'param': 'slope', 'multiplier': 3.0}),
}

def shock_policy(params, step, history, state):
    if step in shock_schedule:
        return {'shock_event': shock_schedule[step]}
    return {'shock_event': None}

# Optuna-driven sweep over shock_t × curve_params produces BC3c

# trait vector computed once per block, persisted to state
def niche_trait_policy(params, step, history, state):
    window = 100
    recent = history[-window:]
    return {'trait_vec': np.array([
        1 - np.std([h['price'] for h in recent]),
        (state['supply'] - recent[0]['supply']) / window,
        1 - gini([h['holders'] for h in recent[-1]]),
        sum(1 for h in recent if h['gov_event']) / window,
        state['tvl'] / state['reserve'],
        1 - np.std([h['price'] / h['peg_target']
                    for h in recent if h['peg_target']]),
    ])}

state_vars['trade_graph'] = nx.DiGraph()

def trade_policy(params, step, history, state):
    swaps = simulate_block_swaps(state)
    return {'swaps': swaps}

def s_trade_graph(params, step, history, state, signals):
    G = state['trade_graph'].copy()
    for sw in signals['swaps']:
        if G.has_edge(sw.from_curve, sw.to_curve):
            G[sw.from_curve][sw.to_curve]['weight'] += sw.volume
        else:
            G.add_edge(sw.from_curve, sw.to_curve, weight=sw.volume)
    # window: decay old edges
    for u, v, d in G.edges(data=True):
        d['weight'] *= 0.99
    return ('trade_graph', G)

# at the meta-simulation level: each cadCAD run = one (x₀, y₀, a, b, c, d) point
# wrap in a parameter sweep
sweep = {
    'a':      np.linspace(0.2, 1.5, 30),
    'c':      np.linspace(0.2, 1.5, 30),
    'x_init': [40],
    'y_init': [12],
    'b':      [0.025],
    'd':      [0.018],
}
# Optuna or grid runs the sweep; classification policy labels outcomes
# from the final 200-step window of each run.

def mimesis_policy(params, step, history, state):
    candidates = visible_curves(state, radius=params['vis_r'])
    higher_fit = [c for c in candidates if c.fitness > state.fitness]
    if not higher_fit:
        return {'imitation': None}
    weights = np.exp(params['beta'] * np.array([c.fitness for c in higher_fit]))
    target = np.random.choice(higher_fit, p=weights / weights.sum())
    mech = pick_mechanism_to_copy(target, state, niche_overlap=...)
    return {'imitation': (target.id, mech)}

# MAP-Elites loop wraps the cadCAD simulation
archive = {}     # (vol_bin, gini_bin) → (genome, fitness)

def map_elites_step(rng):
    if len(archive) < params['init_pop']:
        genome = sample_random_genome(rng)
    else:
        parent_key = rng.choice(list(archive))
        genome = mutate(archive[parent_key][0], rng)
    result = run_cadcad(genome)             # full cadCAD run
    bd1, bd2 = compute_descriptors(result)
    fit = compute_fitness(result)
    key = (bin(bd1), bin(bd2))
    if key not in archive or archive[key][1] < fit:
        archive[key] = (genome, fit)

Each evaluation is one cadCAD run. Optuna's TPE can drive the mutation operator for more sample-efficient exploration than uniform mutation.