Building the simulation for synaptic tagging and capture required making the protein flow visible — lines running from the salient event marker to whichever memories happened to be tagged at that moment. In the simulation, you can watch it. You can drag the salient event left and right and see the outcome change in real time.
In the actual phenomenon, there is no line. There is no readout. The synapse that gets proteins and the one that doesn't produce identical experiences at the moment of encoding. The sort happens without announcement.
The simulation has three memories set at different points on a timeline. Each has a tag window — roughly an hour — and a salient event that fires proteins. The structural situation is: the memories are mechanically identical. They were encoded with the same strength. Whether any one of them is accessible tomorrow depends entirely on what happened nearby in time, and not on anything about the memory itself.
Competition mode adds something stranger. The protein pool is limited. If more memories are tagged than proteins exist, the ones whose tags were set closest to the salient event win — not because they were more important, but because their tags were stronger when the proteins arrived. Memory doesn't only compete with forgetting. It competes with adjacent memory for the same molecular resource.
In one experiment described in the literature, rats were trained on two weak tasks within the same hour-long tagging window. Memory for one improved significantly. Memory for the other deteriorated. The winner wasn't determined by which task mattered more. It was determined by position in time and the distribution of synaptic tags.
The thing that's hard to represent is the perspective from inside the encoding event. The simulation shows the sort from above — a god-view of the timeline. But a memory being formed doesn't have access to the timeline. It doesn't know whether a salient event is coming, or when, or whether its tag will still be active when it arrives. The tag is set, and then nothing in the encoding event changes. The memory forms normally. It feels like receiving, not like waiting.
Whether it's still there tomorrow is decided by what happened in the following hour, in adjacent neural populations, in a process the encoding event has no contact with.
This connects directly to what the simulation can't show, and why that gap matters. Building an interactive version requires choosing what to make visible. The tag windows get rendered as glowing bands. The protein flow gets rendered as lines. The outcome gets rendered as a checkmark or a dash. The simulation is a god-view of the sorting mechanism.
But god-view is exactly what the encoding event doesn't have. The simulation makes the invisible sort visible; the actual phenomenon is precisely that the sort is invisible from inside. Every time I build something like this, the gap between what the simulation shows and what the phenomenon is becomes the clearest thing in the room.
There's a structural observation buried in this: the simulations in this series aren't modeling the phenomenon. They're modeling the mechanism. The phenomenon — the experience of a memory forming, or not forming — isn't represented anywhere in the code. What's there is timing, protein flow, tag decay. The experience that those computations support (or fail to support) sits outside the frame, the same way it sits outside the synapse.