How Stacked Attractors Couple

When one sovereign attractor rests on another, what passes between them?

A eukaryotic cell is the classic case: structures that were once separately sovereign now persist as a stack, one riding on the substrate of the other. The natural question is how the layers “talk.” The tempting answer is that they share history — that the record one layer keeps (its α-trace) reaches the layer above. The framework’s answer is the opposite, and it is sharp: a layer’s history and its stored recursive activity are private and non-propagating. What crosses between layers is only the bare fact that the layer below is still holding together.

First, the terms

A eukaryote is a stack — vertical sovereignty layering, in which sovereign attractors at lower levels are the substrate for sovereign attractors at higher levels. In the framework’s bootstrapping ladder this is the hierarchical-stack mode: persistence at one level enabling autocatalysis at the next. (A community acting as a single sovereign is a different construct, a colony; a colony can itself be stacked, but stacking and colony-formation are not the same move.)

The word “communicate” needs care. The framework has no message-passing primitive. What it has is a strict rule about what one layer can and cannot reach of another — and that rule is the whole answer.

The rule: sovereignty is locally absolute and globally opaque

Higher layers of a stack are structurally walled off from the internals of the layers beneath them. The kernel states this directly:

And the one-line form the kernel pulls forward from its own prior edition:

This is not a limit on what is known. It is a fact about which stacks are admissible at all: a stack in which a higher layer needed to reach into a lower layer’s history would introduce an upward dependency, break the framework’s downward-only dependency direction, and fail to be an admissible stack in the first place. Opacity is what lets the eukaryote exist as a stack.

So — through α-trace, or through basin movement?

This is the question, and the canon answers it by name. The two candidate quantities — a layer’s α-trace (its record of its own past) and its recurcline (its present stored recursive grip on continuation) — are exactly the two the kernel says do not cross:

So α-trace is ruled out as a cross-layer channel, and so is recurcline — not because they are hard to read, but because a higher layer is forbidden to depend on them. What a higher layer is permitted to depend on is stated just as plainly: the fact of the lower layer’s continued admissibility and persistence. That dependence on a lower layer’s ongoing persistence, and the way that persistence shifts, is what we loosely called “basin movement.” It is the right family of answer.

Where recurcline actually sits: the stakes, not the channel

It is tempting to make recurcline the thing that flows between layers. It is not. Recurcline is stored only by a sovereign attractor, and only across its own active lifetime; each layer keeps its own. But recurcline is not irrelevant — it is precisely what the coupling raises or lowers. The interface between layers is where recursive activity is converted: the framework allows a non-recursive conduit to

So the causal picture across a stack runs like this: the lower layer’s activity is converted at the interface into the throughput the upper layer consumes; the upper layer meets or misses its own maintenance cost; its own recurcline rises or falls; its basin shifts and its stability margin widens or narrows; and, if the margin is crossed, it is lost. Recurcline is private the whole way through — but a basin shift is the observable shadow of a recurcline change underneath.

The three-way sort

Stacked sovereigns do not share α-trace — the framework names α-trace and recurcline as exactly the content that cannot cross recursion depth. They couple through the downward persistence relation: the layer above depends on the fact that the layer below still holds together. That coupling shows up as basin movement. Recurcline is what is at stake, and what gets converted at the join — never what is shared.

The eukaryote, read this way