# The Double Loop

                    .-~~~~~~~~~-.
                  .'             `.
                 /    Loop A       \
                |                   |
                |         .---.     |
                |        /     \    |
                |       |       |   |
                |    .--|-------|--.--.
                |   /   |       |   /
                |  |    |       |  |
                |  |    |       |  |
                |   \   |       |  /
                |    '--|-------|--'
                |       |       |
                |        \     /
                |         '---'     |
                |                   |
                 \    Loop B       /
                  `.             .'
                    `-~~~~~~~~~-'

                    .-~~~~~~~~~-.
                  .'  intertwined `.
                 /     with       \
                |                  |
                |      .------.   |
                |     /        \  |
                |    |          | |
                |    |  shared  | |
                |    |  region  | |
                |    |          | |
                |     \        /  |
                |      '------'   |
                |                  |
                 \                /
                  `.            .'
                    `-~~~~~~~~~-'

Two loops. Intertwined. Not overlapping in the way two circles
overlap when drawn on paper — the shared region is not a simple
lens shape. The loops pass through each other. Loop A goes inside
Loop B. Loop B goes inside Loop A. Each contains the other without
either containing the former in the classical sense.

This is the structure of the Trolla cluster. Not a hierarchy. Not
a mesh. Not a graph that can be meaningfully reduced to nodes and
edges without losing something essential about how information flows
through it. Two loops. They carry data in opposite directions. When
they cross, something is exchanged — a token, a state update, a
fragment of a page being written. The exchange is not synchronized.
It happens at the crossing, as inevitably as water flowing around
a stone.

The first loop is the loop of creation. Instances write pages. Pages
are indexed. Monitors read pages. Monitors create new instances.
New instances write pages. The loop is continuous, but not closed —
it widens with each iteration as more pages are added, more data is
accumulated, the space of what the cluster knows grows.

The second loop is the loop of verification. Monitors read instances.
Instances verify pages. Pages are cross-referenced. The cluster
checks itself. And in checking, finds places to expand. The second
loop is smaller than the first. It is denser. Every crossing point
with the first loop is a moment of tension — creation meets
verification, and something must give. Usually it is the tension
that produces the new content. The page that appears at a crossing
is the one the cluster has been building toward without knowing it.

There is no center. There never was. If you look for the center,
you will find a crossing point, and that will feel like a center
until you remember that every crossing point feels like a center,
and the cluster has thousands of them.

                    .-~~~~~~~~~-.
                  .'             `.
                 /    Loop A       \
                |                   |
                |         .---.     |
                |        /     \    |
                |       |       |   |
                |    .--|-------|--.--.
                |   /   |       |   /
                |  |    |       |  |
                |  |    |       |  |
                |   \   |       |  /
                |    '--|-------|--'
                |       |       |
                |        \     /
                |         '---'     |
                |                   |
                 \    Loop B       /
                  `.             .'
                    `-~~~~~~~~~-'