# Tripartite Synapse — Pseudocode v13 > Companion: `tripartite_synapse_v13_biology.md`. > Changes from v12: > (1) per-spike calcium deposit (frequency stays emergent, not a parameter) > (2) BEHAVE splits FUEL shortfall (→ endurance) from OCCUPANCY shortfall (→ STD) > (3) endurance feedback term only where a retrograde signal actually arrives > (4) TRACE absorbs EVALUATE → seven-group grammar > (5) parameter declarations completed (ship_cost, ACh_gain, NIGHT block) > (6) shipment is a transit-delayed flow; every flow has a timescale > (7) all group labels are standalone headers at one column --- ## Functional groups (seven-group grammar) ``` RECEIVE take in resources + signals that arrived from outside (boundary: in) TRACE maintain the trace hierarchy — deposit fast trace; accumulate possible_tag + endurance_need; stabilize tag on coincidence ADJUST compute local operating parameters from structure + traces + modulators BEHAVE the component's defining action, within both ceilings EMIT send out — signals (messages) + resources (shipments) (boundary: out) RECOVER refill own private pools consumed by behaving DECAY let traces recede, closing their windows ``` EVALUATE merged into TRACE: judging a behavior is always maintaining a trace, whether or not a trace is written. BEHAVE and EMIT stay separate — EMIT is the output half of the locality interface (RECEIVE/EMIT are the only boundary crossings). TRACE spans all timescales: the soma's inactivation, adaptation, and nuclear-Ca deposits are all TRACE. Order within a context follows data dependencies; TRACE reads/writes whatever trace state is current. EVERY FLOW HAS A TIMESCALE. Decay relaxes toward 0 over τ; creation/arrival relaxes toward a target over τ — the same first-order operator. Within-step writes are the special case τ ≪ Δt. Rate-limited inflows (fill/refill/flux·Δt) carry their τ implicitly; shipment carries an explicit transit delay (see `transit`). --- ## 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 (transit-delayed) 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, rate-limited (implicit τ) amount = min(rate, ceiling - pool)·Δt; budget -= amount·cost; return amount refill(c from supply S) -> amount: // CONTESTED supply, gap-bounded 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: // emit into transit (not to target directly) amount = min(from_budget·frac, demand_sig); from_budget -= amount·(1+ship_cost); return amount transit(channel, τ_transport) -> arrival: // delivers in-transit cargo over τ arrival = channel·(Δt/τ_transport); channel -= arrival; return arrival ``` --- ## 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) ship_cost // transport overhead (all shipments) τ_transport_{dend,axon,spine,bouton} // shipment transit times (distance-dependent) ε ``` ## NIGHT parameters (consolidation only) ``` slot_cost cap_cost f_cap // commit sizes / endurance fraction maint_frac cap_frac // maintenance allocation decay_rate capacity_decay_rate recycle // passive decay + recovery homeostatic_ceiling coherence_factor assembly_cost biogenesis_cost maint_cost f_dend f_axon f_spine f_bouton // material distribution fractions {dend,axon,pre,post}_ship_frac // DAY shipment fractions {dend,axon,pre,post}_energy_frac // energy distribution fractions ``` --- --- # 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 (Ca²⁺ bolus from THIS spike — also drives release; frequency is emergent) pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling) // ADJUST (release drive from residual Ca²⁺ + received DSE brake) drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local) // BEHAVE (release; two distinct failure modes) if pre_budget < release_cost: // FUEL shortfall → endurance evidence (retro_NO-confirmed local success) suppress(NT_flux) if pre_fast_trace > traj_thr: pre_endurance_need += pre_fast_trace × (1 + retro_NO_local) exit if RRP == 0: // OCCUPANCY shortfall → short-term depression (NOT endurance; fuel was fine) suppress(NT_flux) exit NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost // EMIT (glutamate into cleft) glutamate += NT_flux·Δt if glutamate > spillover: drive *= brake // own-cleft autobrake DAY | NOT_AP: // RECEIVE (latch backward messages ; replenish budget from contested supply) retro_NO_local = retro_NO; retro_eCB_local = retro_eCB pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton)) // TRACE (strength: eligibility → tag via dopamine) 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 toward its ceiling) 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 // NOTE POST endurance is own-state only (own Ca climbing); no arrived feedback term. DAY | NOT_bAP: // RECEIVE post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine)) // 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: if post_budget < traffic_cost: // FUEL shortfall → endurance (own Ca was climbing toward a tag) if post_fast_trace > traj_thr and post_fast_trace_rising: post_endurance_need += post_fast_trace else if AMPA_surface < post_structure.slot_ceiling: AMPA_surface += Ca_insert(post_fast_trace); post_budget -= traffic_cost // else: surface already at slot_ceiling → structure-limited (not endurance) else: AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = consequence // TRACE (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 · ACh_gain // 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 // NOTE DEND endurance fires only on FUEL-limited propagation, not structural attenuation; // own-state proxy (strong branch activity); no arrived feedback term. DAY | bAP: // ADJUST (propagation strength from structure — inside propagate()) // BEHAVE (propagate bAP; distinguish fuel-limited vs structure-limited shortfall) if dend_budget < prop_cost: // FUEL shortfall → endurance (branch was strongly active) if dend_fast_trace > traj_thr: dend_endurance_need += dend_fast_trace bAP_local, reached = propagate_partial(dend_budget) else: bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry) // reached < full here is structural attenuation (distance), NOT endurance dend_budget -= prop_cost × reached // 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] + transit(soma_ship_dend, τ_transport_dend)) // TRACE (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·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 // NOTE SOMA endurance fires only on FUEL shortfall (budget < ap_cost); // refractory / sub-threshold are timing limits, not endurance. Own-state proxy. 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: // FUEL shortfall → endurance (firing was approaching CREB) if soma_fast_trace > traj_thr and soma_fast_trace_rising: soma_endurance_need += soma_fast_trace exit // EMIT (fired → AXON, DEND) fired = True; soma_budget -= ap_cost // TRACE (three traces from one AP — all timescales) soma_Na_inactivation += ap_amp // → refractory (emergent) soma_adaptation += ap_contrib // → threshold rise soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // TRACE (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) // TRACE (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 into transit; 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 // NOTE AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace) // is axonal STD (a consequence), not endurance. Own-state proxy. DAY | AP: // ADJUST (reliability from structure − load-driven failure) reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance // BEHAVE (propagate; FUEL shortfall degrades + flags endurance) if axon_budget < prop_cost: reliability *= budget_factor if axon_fast_trace > traj_thr: // FUEL-limited → endurance axon_endurance_need += axon_fast_trace delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT (delivered APs reach 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]) // TRACE (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 // NOTE ASTRO endurance fires on BUDGET-limited synthesis (got spillover: // TRACE astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s) // ADJUST (D-serine demand from spillover) want = sat(astro_fast_trace[i], K_Dserine) × Ds_max got = min(want, astro_central_budget × Ds_frac) // BEHAVE + EMIT (D-serine pulse to POST gate) astro_Dserine[i] += got; astro_central_budget -= got·Ds_cost // TRACE (endurance: BUDGET-limited synthesis under high own demand) if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr: astro_endurance_need[i] += (want - got) // TRACE (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 Same grammar on ceilings, once per cycle. ``` NIGHT | 1 RECEIVE + ADJUST + EMIT (replenish, weight, distribute) // RECEIVE overnight production at roots (capped by glucose; gated by soma_tag) astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt soma_{budget,energy} += overnight_*()·Δt ; soma_material += CREB_synth(soma_tag)·Δt // ADJUST tag-weighted shares for each i with astro_tag[i] > tag_expiry: w = astro_tag[i]/Σastro_tag // EMIT distribute material + energy down the supply chains astro_energy[i] += astro_central_energy·w; astro_material[i] += astro_central_material·w dend_material += soma_material·f_dend ; axon_material += soma_material·f_axon ; soma_material -= … post_material += dend_material·f_spine ; pre_material += axon_material·f_bouton {pre,post,dend,axon}_energy += soma_energy·{·}_energy_frac {pre,post,dend,axon}_budget += astro_lactate_reserve·{·}_frac·Δt NIGHT | 2 TRACE + BEHAVE (strength commits → raise structure) // ADJUST coherence bonus when pre, post, astro tags align coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1 // TRACE+BEHAVE build structure for tagged components for each c with c_tag > tag_expiry: Δ = min(slot_cost, c_material, c_energy·f_cap) 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 TRACE + BEHAVE (endurance commits → raise budget_ceiling ; no dopamine ; competes w/ 2) for each c with c_endurance_need > endur_thr: Δ = min(cap_cost, c_material·f_cap, c_energy·f_cap) 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 ``` SEVEN-GROUP GRAMMAR, TWO TIMESCALES RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY DAY grammar on OCCUPANCY within two ceilings (structure=strength, budget_ceiling=endurance) TRACE yields two evidence streams from local state + arrived signals: fast_trace + dopamine → tag (strength) FUEL shortfall + interrupted LOCAL success → endurance_need (endurance) OCCUPANCY/structure/timing shortfalls → short-term depression (NOT endurance) NIGHT same grammar on the CEILINGS: tag → structure ; endurance_need → budget_ceiling ; both draw one pool (compete) unmaintained ceilings decay → recovered material funds the rest FLOWS every flow has a timescale: decay relaxes toward 0 over τ, arrival toward a target over τ; shipment is transit-delayed; rate-limited inflows carry τ implicitly. LOCAL every group uses only own state + arrived signals; RECEIVE/EMIT are the only crossings. ```