# Tripartite Synapse — Pseudocode v11

> Companion: `tripartite_synapse_v11_biology.md` explains the biology of every variable.
> Changes from v10: each component now carries its own PARAMETERS and EXTERNAL INTERFACE
> blocks; behaviors are organized into functional groups within each context; pool-filling
> primitives return their increment (applied by the caller); the astrocyte no longer writes
> PRE's drive (the spillover brake is PRE reading its own cleft).

---

## Functional groups (the uniform template, applied within each context)

```
RECEIVE   take in resources + signals that arrived from outside
BEHAVE    the component's defining action
EMIT      send out — signals (messages) and resources (shipments) across the boundary
SENSE     deposit the fast trace that records the behavior
RECOVER   refill own private pools consumed by behaving
EVALUATE  judge the behavior — strength (needs dopamine) + endurance (interrupted success)
DECAY     let traces recede, closing their windows
```
Groups sit inside the DAY contexts (Option A): execution contexts (AP/bAP/CONTINUOUS) carry
BEHAVE/EMIT/SENSE/endurance-EVALUATE; replenishment contexts (NOT_AP/NOT_bAP) carry
RECEIVE/RECOVER/strength-EVALUATE/DECAY. Not every component uses every group.

---

## 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 (each component writes, others read)
  glutamate     PRE → POST, ASTRO     forward transmitter; ASTRO clears it
  astro_Dserine ASTRO → POST          NMDA co-agonist gate
  retro_NO      POST → PRE  (+)        "release reached a responsive target"
  retro_eCB     POST → PRE  (−)        DSE: "over-driven, release less"

SHIPMENT CHANNELS (source writes, target reads in its RECEIVE)
  soma_ship_dend SOMA→DEND   soma_ship_axon SOMA→AXON
  dend_ship_post DEND→POST   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                                  // intrinsic refill 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                                // consumes shared supply
    return demand·factor

ship(from_budget, demand_sig, frac, cost) -> amount:       // DIRECTED transfer
    amount       = min(from_budget·frac, demand_sig)       // demand_sig = propagated tag
    from_budget -= amount·(1 + cost)
    return amount                                          // caller writes shipment channel
```

---

## SHARED parameters (organism / physical / universal plasticity machinery)

```
// organism broadcasts (external; arrive as local levels)
dopamine  NE  ACh
// physical (external)
glucose            // vascular energy ceiling — root
geometry           // dendritic topology — bAP attenuation
// universal plasticity gates (same mechanism in every component)
elig  dop_thr  tag_thr  tag_expiry          // strength: eligibility → tag
traj_thr  endur_thr                         // endurance: interrupted-success → need
// universal NIGHT
decay_rate  capacity_decay_rate  recycle
homeostatic_ceiling  coherence_factor  assembly_cost  biogenesis_cost  maint_cost
// decay-time convention: each *= decay(τ) means relax toward 0 with time-constant τ
```

---
---
# DAY
---

## PRE

```
// PARAMETERS (pre)
//   K_release   half-max Ca²⁺ for release      release_cost  gate to release
//   fusion_cost per unit NT_flux               vatpase_cost  per unit RRP refilled
//   spillover   cleft level for autobrake      brake         autoreceptor factor
//
// EXTERNAL INTERFACE
//   EMIT     glutamate → POST, ASTRO
//   RECEIVE  astro_lactate[syn] ← ASTRO (primary fuel) ; axon_ship_pre ← AXON (fuel)
//            retro_NO, retro_eCB ← POST (backward messages)
//            pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
//   READ     glutamate (own cleft, autobrake) ; dopamine (VTA, gates tag)
//   OWN      pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
//   EMERGENCY shockwave_lockdown ← ASTRO

DAY | AP:
    // SENSE
    pre_fast_trace += spike_Ca(input_freq)
    // BEHAVE — release or fail
    if pre_budget < release_cost:
        suppress(NT_flux)
        // EVALUATE (endurance) — interrupted local success, confirmed by retro_NO
        if pre_fast_trace > traj_thr:
            pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)
        exit
    drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local)
    if RRP > 0:
        NT_flux = RRP × drive
        // EMIT
        glutamate += NT_flux·Δt
        RRP -= NT_flux·Δt;  pre_budget -= NT_flux·fusion_cost
    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)
    // RECOVER
    RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
    // 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
    // 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 (post)
//   K_AMPA      half-max glu for AMPA          AMPA_Ca   Ca fraction via AMPA
//   AMPA_cost  NMDA_cost  bAP_cost  pka_cost   traffic_cost  req_cost
//   Mg_eject   Vm to eject Mg block            Dserine_thr  NMDA co-agonist gate
//   Ca_STP     fill-slots threshold           Ca_TAG    tagging threshold
//   eCB_thr    Vm for endocannabinoid (DSE)    drift  baseline  (STD relaxation)
//   NO_synth_cost  eCB_synth_cost
//
// EXTERNAL 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 (via dend_structure.bAP_fidelity)
//            dopamine (VTA, stabilizes tag)
//   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)
    // BEHAVE + SENSE — three Ca sources feed post_fast_trace
    a = sat(glutamate, K_AMPA)                              // SOURCE 1: AMPA
    AMPA_current = a × AMPA_surface;  Vm += AMPA_current
    post_fast_trace += AMPA_Ca·AMPA_current;  post_budget -= AMPA_cost
    if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:   // SOURCE 2: NMDA
        post_fast_trace += NMDA_Ca(glutamate)·rise_speed();  post_budget -= NMDA_cost
        // EMIT (+)
        retro_NO += NO_emit(post_fast_trace);  post_budget -= NO_synth_cost
    // EMIT (−)
    if Vm > eCB_thr: retro_eCB += eCB_emit(Vm);  post_budget -= eCB_synth_cost
    post_fast_trace *= decay(ms)
    // BEHAVE — STP fill slots (Ca-driven, 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) — interrupted local success (own Ca climbing toward tag)
    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 (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 + SENSE — SOURCE 3: bAP amplifies an existing signal
    Vm += bAP_depol × dend_structure.bAP_fidelity;  post_budget -= bAP_cost
    if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost()
```

---

## DEND

```
// PARAMETERS (dend)
//   prop_cost  branch_Ca_cost  integrate_cost  translate_cost
//
// EXTERNAL 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 (bAP trigger) ; POST.Vm + spine spillover (to integrate)
//            dopamine ; ACh (commit-threshold context)
//   OWN      dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling

DAY | bAP:
    // BEHAVE — propagate bAP (may fall short if depleted), integrate spines
    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 (LOCAL)
    if reached < full and dend_fast_trace > traj_thr:
        dend_endurance_need += dend_fast_trace
    // SENSE
    dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover();  dend_budget -= branch_Ca_cost
    // EMIT — propagated bAP to spines; integrated voltage to soma
    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)
    // EMIT — ship budget downstream to spines (demand = post tag)
    dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
    // 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
    // BEHAVE — local translation if tagged (fills dend capacity faster)
    if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
    commit_threshold *= 1/(1 + ACh·gain)
    // DECAY
    dend_fast_trace *= decay(300ms);  dend_possible_tag *= decay(s)
    dend_endurance_need *= decay(min);  dend_tag *= decay(hr)
```

---

## SOMA

```
// PARAMETERS (soma)
//   ap_cost  nuclear_cost  creb_cost            mito_output  (self-fuel rate)
//   inactivation  ap_amp  ap_contrib            base_recovery
//   τ_Na  τ_adapt  τ_nuclear  τ_align
//
// EXTERNAL 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:
    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:
            // EVALUATE (endurance) — fuel cut a firing train approaching CREB (LOCAL)
            if soma_fast_trace > traj_thr and soma_fast_trace_rising:
                soma_endurance_need += soma_fast_trace
            exit
        fired = True;  soma_budget -= ap_cost              // EMIT: fired → AXON, DEND
        // SENSE — 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:
    // 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
    // RECOVER — recovery rate sped by alignment trace
    recovery = base_recovery × (1 + soma_refractory_alignment)
    soma_Na_inactivation *= decay(τ_Na / recovery)
    // RECEIVE — self-replenish (private root) + integrate input
    soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
    branch_Vm = integrate(DEND.branch_Vm, branches)
    // 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)
    // 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 (axon)
//   prop_cost  budget_factor  (depleted-propagation penalty)
//
// EXTERNAL 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:
    reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))
    // BEHAVE — propagate (degraded if depleted)
    if axon_budget < prop_cost:
        reliability *= budget_factor
        // EVALUATE (endurance) — propagating a strong train when fuel failed (LOCAL)
        if axon_fast_trace > traj_thr: axon_endurance_need += axon_fast_trace
    delivered = fired × reliability;  axon_budget -= prop_cost × delivered
    // EMIT — delivered APs reach boutons
    // SENSE
    axon_fast_trace += delivered;  axon_fast_trace *= decay(s)

DAY | NOT_AP:
    // RECEIVE
    axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
    // EMIT — ship budget to boutons (demand = pre tag)
    axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
    // 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
    // DECAY
    axon_fast_trace *= decay(s);  axon_possible_tag *= decay(s)
    axon_endurance_need *= decay(min);  axon_tag *= decay(hr)
```

---

## ASTRO

```
// PARAMETERS (astro)
//   K_Dserine  half-max Ca for D-serine        Ds_max  Ds_frac  Ds_cost
//   EAAT_cost  per unit glutamate cleared       lactate_cost  per unit exported
//   spillover  overflow threshold               overload  lockdown threshold
//
// EXTERNAL 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
    // EMIT — demand-weighted lactate allocation across territory
    for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
    factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
    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:
        // SENSE
        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 (LOCAL)
        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
System-wide consolidation (not a per-component DAY cycle). Build ceilings from DAY evidence.

```
NIGHT | 1  REPLENISH & DISTRIBUTE
    // energy economy: astrocyte central → astrosynapses (astro_tag-weighted)
    astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt
    for each i with astro_tag[i] > tag_expiry:  w = astro_tag[i]/Σastro_tag
        astro_energy[i] += astro_central_energy·w;  astro_material[i] += astro_central_material·w
    // material economy: soma → branch/axon → spine/bouton
    soma_budget += overnight_mito()·Δt;  soma_energy += overnight_soma_energy()·Δt
    soma_material += CREB_synth(soma_tag)·Δt                // bottleneck
    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·f[·]
    {pre,post,dend,axon}_budget += astro_lactate_reserve·f[·]·Δt

NIGHT | 2  STRENGTH COMMITS (raise structure)
    coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1
    for each c with c_tag > tag_expiry:
        Δ = min(slot_cost, c_material, c_energy·f)
        c_structure += Δ × (coherence if c in {pre,post,astro} else 1)
        c_material -= Δ;  c_energy -= Δ·assembly_cost
        if Δ < slot_cost: queue(c_strength_deficit → next NIGHT)

NIGHT | 2b ENDURANCE COMMITS (raise budget_ceiling) — no dopamine; competes with step 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 Δ < cap_cost: queue(c_endurance_deficit → next NIGHT)

NIGHT | 3  PASSIVE DECAY (both ceilings, by neglect)
    maint = (total_material - consumed) × maint_frac / synapse_count
    for each synapse:
        {pre,post,dend,astro}_structure      -= decay_rate·Δt
        {pre,post,dend,astro}_budget_ceiling -= capacity_decay_rate·Δt
        if maint ≥ maint_cost: structure += full_maint;  budget_ceiling += full_cap_maint
        else:                  structure += maint·frac;  budget_ceiling += maint·cap_frac
    for each synapse with net_change < 0:                  // material recovered, energy not
        {pre,post,astro}_material += |net_change|·recycle·frac

NIGHT | 4  HOMEOSTATIC SCALING
    if soma_tag > 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  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, per component: RECEIVE → BEHAVE/EMIT/SENSE → RECOVER → EVALUATE → DECAY
       behavior runs within structure (strength) and budget_ceiling (endurance),
       both filled by competition (refill = contested, fill = private, ship = directed)
       fast_trace + dopamine coincidence  → tag            (strength evidence)
       depletion + interrupted LOCAL success → endurance_need (endurance evidence)
NIGHT  tag → structure ; endurance_need → budget_ceiling ; both draw one pool (compete)
       unmaintained ceilings decay → freed material funds the rest
LOCAL  every evaluation uses only own state + arrived signals; coupling is via channels.
```
