# Tripartite Synapse — Pseudocode v12 > Companion: `tripartite_synapse_v12_biology.md`. > Changes from v11: SENSE renamed TRACE; new ADJUST group (compute local operating > parameters from structure + traces + modulators); reference order puts EVALUATE before > ADJUST and DECAY; NIGHT labeled with the same group grammar; all `// GROUP` headers sit > at one indentation column so they stand out. --- ## Functional groups (uniform grammar, applied within each context) ``` RECEIVE take in resources + signals that arrived from outside EVALUATE judge behavior — strength (needs dopamine) + endurance (interrupted success) ADJUST compute local operating parameters from structure + traces + modulators BEHAVE the component's defining action, using the adjusted parameters EMIT send out — signals (messages) and resources (shipments) across the boundary TRACE deposit the fast trace that records the behavior RECOVER refill own private pools consumed by behaving DECAY let traces recede, closing their windows ``` Groups sit inside the DAY contexts (Option A). Execution contexts (AP/bAP/CONTINUOUS) carry ADJUST/BEHAVE/EMIT/TRACE and endurance-EVALUATE; replenishment contexts (NOT_AP/NOT_bAP) carry RECEIVE/strength-EVALUATE/RECOVER/DECAY. Not every component uses every group. Group order within a context follows data dependencies (e.g. where a fast trace both drives a behavior and records it, TRACE precedes ADJUST). NIGHT runs the same grammar on ceilings. --- ## Conventions ``` SCOPE = {DAY, NIGHT} CONTEXT = {AP, NOT_AP, bAP, NOT_bAP, CONTINUOUS} DAY budget · fast_trace · possible_tag · endurance_need BRIDGE tag (POST: CANDIDATE→STABLE) NIGHT energy (not recoverable) · material (recoverable) · structure · budget_ceiling LOCALITY only local state + arrived signals; no component reads another's internal state. CLEFT MESSAGE CHANNELS SHIPMENT CHANNELS glutamate PRE → POST, ASTRO soma_ship_dend SOMA→DEND astro_Dserine ASTRO → POST soma_ship_axon SOMA→AXON retro_NO POST → PRE (+) dend_ship_post DEND→POST retro_eCB POST → PRE (−) axon_ship_pre AXON→PRE ``` --- ## Primitives (return the increment; caller applies it) ``` sat(x, K) = x / (K + x) fill(pool, ceiling, rate, cost, budget) -> amount: // PRIVATE reserve amount = min(rate, ceiling - pool)·Δt; budget -= amount·cost; return amount refill(c from supply S) -> amount: // CONTESTED supply demand = c.budget_ceiling - c.budget factor = min(1, S / (Σ demand over components on S + ε)); S -= demand·factor return demand·factor ship(from_budget, demand_sig, frac, cost) -> amount: // DIRECTED transfer amount = min(from_budget·frac, demand_sig); from_budget -= amount·(1+cost); return amount ``` --- ## SHARED parameters ``` dopamine NE ACh // organism broadcasts (external) glucose geometry // physical (external) elig dop_thr tag_thr tag_expiry // strength gates (universal) traj_thr endur_thr // endurance gates (universal) decay_rate capacity_decay_rate recycle homeostatic_ceiling coherence_factor assembly_cost biogenesis_cost maint_cost ``` --- --- # DAY --- ## PRE ``` // PARAMETERS K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake // INTERFACE // EMIT glutamate → POST, ASTRO // RECEIVE astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; retro_NO, retro_eCB ← POST // pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT) // READ glutamate (own cleft, autobrake) ; dopamine (gates tag) // OWN pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling // EMERGENCY shockwave_lockdown ← ASTRO DAY | AP: // TRACE (residual Ca²⁺ from this spike — also drives release) pre_fast_trace += spike_Ca(input_freq) // ADJUST (release drive from trace + received DSE brake) drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local) // BEHAVE (release or fail) if pre_budget < release_cost: suppress(NT_flux) if pre_fast_trace > traj_thr: // EVALUATE (endurance): retro_NO-confirmed pre_endurance_need += pre_fast_trace × (1 + retro_NO_local) exit if RRP > 0: NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost // EMIT glutamate += NT_flux·Δt if glutamate > spillover: drive *= brake // own-cleft autobrake DAY | NOT_AP: // RECEIVE retro_NO_local = retro_NO; retro_eCB_local = retro_eCB pre_budget += refill(pre from astro_lactate[syn] + axon_ship_pre) // EVALUATE (strength) if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace if dopamine > dop_thr and pre_possible_tag > tag_thr: pre_tag += dopamine × pre_possible_tag // RECOVER (RRP from private reserve) RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget) // DECAY pre_fast_trace *= decay(100ms); pre_possible_tag *= decay(s) pre_endurance_need *= decay(min); pre_tag *= decay(hr) dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s) ``` --- ## POST ``` // PARAMETERS K_AMPA · AMPA_Ca · AMPA_cost · NMDA_cost · bAP_cost · pka_cost · traffic_cost // req_cost · Mg_eject · Dserine_thr · Ca_STP · Ca_TAG · eCB_thr · drift · baseline // NO_synth_cost · eCB_synth_cost // INTERFACE // EMIT retro_NO (+), retro_eCB (−) → PRE // RECEIVE astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND // post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT) // READ glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP (dend_structure.bAP_fidelity) ; dopamine // OWN post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling // EMERGENCY shockwave_lockdown ← ASTRO DAY | NOT_bAP: // RECEIVE post_budget += refill(post from astro_lactate[syn] + dend_ship_post) // ADJUST (AMPA drive from arrived glutamate) a = sat(glutamate, K_AMPA) // BEHAVE (SOURCE 1 AMPA: current + small Ca + begins Mg ejection) AMPA_current = a × AMPA_surface; Vm += AMPA_current; post_budget -= AMPA_cost // TRACE (Ca deposited by AMPA) post_fast_trace += AMPA_Ca·AMPA_current // BEHAVE (SOURCE 2 NMDA: large Ca on local coincidence) if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0: post_fast_trace += NMDA_Ca(glutamate)·rise_speed(); post_budget -= NMDA_cost // EMIT (+) NO/BDNF: "release reached a responsive target" retro_NO += NO_emit(post_fast_trace); post_budget -= NO_synth_cost // EMIT (−) endocannabinoid (DSE) when over-driven if Vm > eCB_thr: retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost post_fast_trace *= decay(ms) // BEHAVE (STP: fill slots from private reserve ; else STD drift = consequence) if post_fast_trace > Ca_STP: AMPA_surface = min(AMPA_surface + Ca_insert(post_fast_trace), post_structure.slot_ceiling) post_budget -= traffic_cost else: AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // EVALUATE (endurance: own Ca was climbing toward a tag when fuel failed) if post_budget < req_cost and post_fast_trace > traj_thr and post_fast_trace_rising: post_endurance_need += post_fast_trace // EVALUATE (strength: CANDIDATE then STABLE via dopamine) if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace; post_budget -= pka_cost if dopamine > dop_thr and post_possible_tag > tag_thr: post_tag += dopamine × post_possible_tag // DECAY post_possible_tag *= decay(min); post_endurance_need *= decay(min) post_tag *= decay(hr); dopamine *= decay(ms) DAY | bAP: // BEHAVE (SOURCE 3 bAP: depolarization + Ca, amplifies existing signal) Vm += bAP_depol × dend_structure.bAP_fidelity; post_budget -= bAP_cost // TRACE (supralinear boost only if a CANDIDATE is present) if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost() ``` --- ## DEND ``` // PARAMETERS prop_cost · branch_Ca_cost · integrate_cost · translate_cost // INTERFACE // EMIT bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST // RECEIVE astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT) // READ SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh // OWN dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling DAY | bAP: // ADJUST (propagation strength from structure) -> inside propagate() // BEHAVE (propagate bAP; may fall short if depleted) bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, dend_budget, geometry) dend_budget -= prop_cost × reached // EVALUATE (endurance: propagation cut short while branch strongly active) if reached < full and dend_fast_trace > traj_thr: dend_endurance_need += dend_fast_trace // TRACE dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost // EMIT (integrated voltage to soma ; propagated bAP already reached spines) branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost DAY | NOT_bAP: // RECEIVE dend_budget += refill(dend from astro_lactate[branch] + soma_ship_dend) // EVALUATE (strength) if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace if dopamine > dop_thr and dend_possible_tag > tag_thr: dend_tag += dopamine × dend_possible_tag // ADJUST (commit threshold lowered by attention) commit_threshold *= 1/(1 + ACh·gain) // EMIT (ship budget to spines; demand = post tag) dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost) // BEHAVE (local translation if tagged — fills dend capacity faster) if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost // DECAY dend_fast_trace *= decay(300ms); dend_possible_tag *= decay(s) dend_endurance_need *= decay(min); dend_tag *= decay(hr) ``` --- ## SOMA ``` // PARAMETERS ap_cost · nuclear_cost · creb_cost · mito_output · inactivation · ap_amp · ap_contrib // base_recovery · τ_Na · τ_adapt · τ_nuclear · τ_align // INTERFACE // EMIT fired → AXON (propagate) + DEND (bAP) ; soma_ship_dend → DEND ; soma_ship_axon → AXON // RECEIVE self (mitochondria, ROOT) ; branch_Vm ← DEND // READ dopamine ; NE ; ACh // OWN soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling DAY | AP: // ADJUST (threshold from structure + adaptation + neuromodulators ; refractory gate) threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh) can_fire = soma_Na_inactivation < inactivation // BEHAVE (fire if able) if branch_Vm > threshold and can_fire: if soma_budget < ap_cost: if soma_fast_trace > traj_thr and soma_fast_trace_rising: // EVALUATE (endurance) soma_endurance_need += soma_fast_trace exit fired = True; soma_budget -= ap_cost // EMIT: fired → AXON, DEND // TRACE (three traces from one AP) soma_Na_inactivation += ap_amp // → refractory (emergent) soma_adaptation += ap_contrib // → threshold rise soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // EVALUATE (strength) if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace if dopamine > dop_thr and soma_possible_tag > tag_thr: soma_tag += dopamine × soma_possible_tag soma_budget -= creb_cost DAY | NOT_AP: // RECEIVE (self-replenish from private root ; integrate input) soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget) branch_Vm = integrate(DEND.branch_Vm, branches) // BEHAVE (bottom-up refractory alignment: suprathreshold input during refractory) if branch_Vm > threshold and soma_Na_inactivation > inactivation: soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation // EMIT (ship downstream; demand = propagated tags) soma_ship_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost) soma_ship_axon = ship(soma_budget, axon_demand, axon_ship_frac, ship_cost) // RECOVER (inactivation recovery sped by alignment trace → emergent refractory) recovery = base_recovery × (1 + soma_refractory_alignment) soma_Na_inactivation *= decay(τ_Na / recovery) // DECAY soma_adaptation *= decay(τ_adapt); soma_fast_trace *= decay(τ_nuclear) soma_refractory_alignment *= decay(τ_align) // self-limiting soma_possible_tag *= decay(s); soma_endurance_need *= decay(min) soma_tag *= decay(hr); dopamine *= decay(ms) ``` --- ## AXON ``` // PARAMETERS prop_cost · budget_factor // INTERFACE // EMIT APs_delivered → PRE (propagation) ; axon_ship_pre → PRE // RECEIVE soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT) // READ SOMA.fired ; dopamine // OWN axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling DAY | AP: // ADJUST (reliability from structure − load-driven failure) reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // BEHAVE (propagate; degraded if depleted) if axon_budget < prop_cost: reliability *= budget_factor if axon_fast_trace > traj_thr: // EVALUATE (endurance) axon_endurance_need += axon_fast_trace delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT → boutons // TRACE axon_fast_trace += delivered; axon_fast_trace *= decay(s) DAY | NOT_AP: // RECEIVE axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft]) // EVALUATE (strength) if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace if dopamine > dop_thr and axon_possible_tag > tag_thr: axon_tag += dopamine × axon_possible_tag // EMIT (ship to boutons; demand = pre tag) axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost) // DECAY axon_fast_trace *= decay(s); axon_possible_tag *= decay(s) axon_endurance_need *= decay(min); axon_tag *= decay(hr) ``` --- ## ASTRO ``` // PARAMETERS K_Dserine · Ds_max · Ds_frac · Ds_cost · EAAT_cost · lactate_cost · spillover · overload // INTERFACE // EMIT astro_lactate[i] → pre/post/dend budgets ; astro_Dserine[i] → POST (gate) // RECEIVE glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT) // READ glutamate ← PRE (clearance + spillover) ; dopamine // OWN astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling // EMERGENCY emits shockwave_lockdown on overload DAY | CONTINUOUS: // per astrosynapse i // RECEIVE (root production, capped by glucose) astro_central_budget += glycolysis(glucose)·Δt // ADJUST (demand weights across territory) for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε)) // EMIT (demand-weighted lactate to all components) for each i: astro_lactate[i] = demand[i] × factor; astro_central_budget -= astro_lactate[i]·lactate_cost // BEHAVE (clear glutamate ; supply tonic D-serine) glutamate[i] -= astro_structure[i].EAAT × glutamate[i]·Δt; astro_central_budget -= clearance·EAAT_cost astro_Dserine[i] += astro_structure[i].Dserine_tonic·Δt if glutamate[i] > spillover: // TRACE astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s) // BEHAVE + EMIT (D-serine pulse: demand-driven, budget-limited) want = sat(astro_fast_trace[i], K_Dserine) × Ds_max got = min(want, astro_central_budget × Ds_frac) astro_Dserine[i] += got; astro_central_budget -= got·Ds_cost // EVALUATE (endurance: ran out of synthesis under high own demand) if got < want and astro_fast_trace[i] > traj_thr: astro_endurance_need[i] += (want - got) // EVALUATE (strength) if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i] if dopamine > dop_thr and astro_possible_tag[i] > tag_thr: astro_tag[i] += dopamine × astro_possible_tag[i] // DECAY astro_possible_tag[i] *= decay(s); astro_endurance_need[i] *= decay(min); astro_tag[i] *= decay(hr) // EMERGENCY if astro_fast_trace[i] > overload: emit(shockwave_lockdown) ``` --- ## Special — Shockwave Lockdown ``` DAY or NIGHT | OVERLOAD: Vm = HYPERPOLARIZED; AMPA_surface = mass_internalize() → post reserve axon_fast_trace += overdrive(); astro_central_budget -= emergency_cost ``` --- --- # NIGHT The same grammar on ceilings: RECEIVE production, EVALUATE/ADJUST the commits, BEHAVE (build ceilings), DECAY (unmaintained ceilings recede). Runs once per cycle, not per spike. ``` NIGHT | 1 RECEIVE + EMIT (replenish and distribute) astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt // RECEIVE soma_{budget,energy} += overnight_*()·Δt ; soma_material += CREB_synth(soma_tag)·Δt // RECEIVE (bottleneck) for each i with astro_tag[i] > tag_expiry: w = astro_tag[i]/Σastro_tag // ADJUST (weights) astro_energy[i] += astro_central_energy·w; astro_material[i] += astro_central_material·w // EMIT dend_material += soma_material·f_dend ; axon_material += soma_material·f_axon ; soma_material -= … // EMIT post_material += dend_material·f_spine ; pre_material += axon_material·f_bouton // EMIT {pre,post,dend,axon}_energy += soma_energy·f[·] ; {…}_budget += astro_lactate_reserve·f[·]·Δt NIGHT | 2 EVALUATE + BEHAVE (strength commits → raise structure) coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1 // ADJUST for each c with c_tag > tag_expiry: // EVALUATE Δ = min(slot_cost, c_material, c_energy·f) // BEHAVE c_structure += Δ × (coherence if c in {pre,post,astro} else 1) c_material -= Δ; c_energy -= Δ·assembly_cost; if Δ < slot_cost: queue(→ next NIGHT) NIGHT | 2b EVALUATE + BEHAVE (endurance commits → raise budget_ceiling ; no dopamine ; competes w/ 2) for each c with c_endurance_need > endur_thr: // EVALUATE Δ = min(cap_cost, c_material·f_cap, c_energy·f_cap) // BEHAVE c_budget_ceiling += Δ; c_material -= Δ; c_energy -= Δ·biogenesis_cost; if Δ homeostatic_ceiling: s = homeostatic_ceiling / soma_tag for each synapse: post_structure.slot_ceiling *= s ; pre_structure.slot_ceiling *= s soma_material += Σ reduction·recycle NIGHT | 5 DECAY (clear traces) all fast_trace, possible_tag, endurance_need = 0 soma_Na_inactivation = soma_adaptation = soma_refractory_alignment = 0 for each tag: if tag < tag_expiry: tag = 0 // else carry forward // structure and budget_ceiling PERSIST ``` --- ## One-view summary ``` DAY per context: RECEIVE → EVALUATE → ADJUST → BEHAVE/EMIT/TRACE → RECOVER → DECAY behavior runs within structure (strength) and budget_ceiling (endurance), both filled competitively (refill = contested, fill = private, ship = directed) fast_trace + dopamine → tag (strength evidence) depletion + interrupted LOCAL success → endurance_need (endurance evidence) NIGHT same grammar on ceilings: tag → structure ; endurance_need → budget_ceiling both draw one pool (compete) ; unmaintained ceilings decay → freed material recycles LOCAL every evaluation uses only own state + arrived signals; coupling is via channels. ```