Wells as Drains of Data

The BPT law

BPT Part 3.9 (Fractal Progeny) makes Null Wells "not dead ends but funnels. They gather the accumulated records of recursion—matter, energy, and informational states—and channel them back toward the foundational substrate." Its Data Funnel Return Law is

Φ⟸ = ∫∫ ρℹ(r, θ) × v⟸(r) dA

the "data flux funneled through Null Well horizons back to the substrate": the Data Density Field ρℹ near the horizon, carried in at the Infall Velocity v⟸ of information-carrying matter, summed over the horizon's area. "Information density collapses inward, encoded onto the horizon, and flows through return channels"; nothing is lost. BPT Part 2.9 adds the Data–Matter Equivalence (G), N⚛ = m_H · 𝒞→² / (k_B · T · ln 2), "the bits one atom of matter is worth": every particle is a swarm of data, so heavy clumps of matter turn the data round them too, without swallowing it (ruling 2026-10-26, app.js:825–827).

The established physics

• Free fall from rest: v = √(2GM/r).
• Kepler's rate Ω = √(GM/r³); Lense–Thirring frame dragging Ω = 2GJ/(c²r³), J = aGM²/c (Lense & Thirring 1918).

The game's math

WellDynamics.step(grids, rows, cols, wells) gravity.js:43 (its driver is also read in Chapter 3, Part 3.11), once a flip from stepWells() app.js:818, on the data grids (lit, color, pulser, exposure, fold):

reachAll = min(reach, ⌊min(rows, cols)/4⌋),   reach = 24 by default (gravity.js:33; app.js:2041 sets only G)
per well:  R = max(1, min(reachAll, w.reach))
swirl (physical wells only), ring k from R down to 1:
   ω_k  = sense·√(G·M/k³) + 2·G²·a·M² / (c³·k³)        radians a flip
   acc += ω_k · k;  shift the ring's cells by ⌊acc⌋ whole cells
infall (every well except swirl-only), ring k from 1 up to R:
   v_k  = min(c, √(2GM/k))
   acc += v_k; if acc ≥ 1, one is taken off it and every data cell on ring k moves one step inward if that cell is empty;
   at k = 1 it is absorbed: the well's count rises by one

Data is never made or doubled: a cell moves only into an empty place, so data piles up near the well (gravity.js:4–7). The frame-drag term is Ω = 2GJ/(c²k³) with J = aGM²/c, written out.

ringPoints(k) gravity.js:19 lists the ring's cells in order, at least 8 sample angles, about 2πk, with each one's inward neighbor.

The driver stepWells() (app.js:818–870):

• G = universeG() (Part 4.3, the Rupture Rule G, not the matter's), c = lightCells().
• Wells and sites; sites are swirl-only (they turn data and swallow none). Proto Wells (data wells) only fall data in, they do not swirl.
• The heaviest 24 bodies of at least 16 cells are added as swirl-only (app.js:829–830).
• With more than 24 non-site wells, each well's reach is half the distance to its nearest neighbor (at least 2), found through a grid of bins about two wells' spacing wide (app.js:838–845).
• The accumulator map is cleared if it passes 40,000 entries (app.js:831).
• What falls in: before the Physical Nova it adds to the well's mass; after it, for physical wells, it streams through, counted on the ledger as dataThrough, not added (ruling 2026-10-28; the capture of Data Matter that is added is in Chapter 3).

In the game

This is the most direct picture the game gives of a well. In the 2D field, and on the torus's skin in 3D, which is the same field, the data cells round each physical well are carried round it in rings, the inner rings faster than the outer, so the data winds into spiral arms; and the cells nearest it step inward into every empty place, piling up round the well "as an accretion disc does" (gravity.js:4–10), until they reach it and are gone. A Proto Well, before the Physical Nova, only draws the data in; a site only turns it. The heaviest clumps of matter turn the data round them as well. In 3D, once there are stars, the data under each of those clumps glows, brightest at the clump and falling as 1/√k to nothing at the edge of the swirl, while the rest of the data lies dim under the stars (drawFieldTexture() app.js:330–348, CLUSTER_GLOW app.js:308).

What falls in is counted. Before the Physical Nova it adds to the Proto Well's mass; the HUD's Void line counts what has gone "into wells" (app.js:2149, with the matter that falls, Part 4.12, and the Data Matter captured, Chapter 3). After it, a physical well's data streams on through, counted on the ledger as dataThrough but not added. No control changes the drains: gravity.js:13–14 says "Nothing here is a free coupling (the panel's 'Well pull' and 'Well swirl' are gone, 2026-10-24)".

The scale model

The data drains run on the cells of the drawn field with the Rupture Rule G (Part 4.3), in whole-cell moves, so they keep the data exactly: nothing is made or doubled. A ring of the drawn field stands for the same share of the universe's area as on the full field; how far out the drains reach, and which clumps turn the data, is set out below.

Where the game and the theory differ

• A fixed reach. The law sums over everything falling toward the horizon. The drains run at most 24 rings out from a well (16 on a phone's 64-cell field, by the quarter-field rule), about a tenth of a desktop field, whatever the well's mass; with more than 24 wells, out to half the way to the nearest neighbor.
• Only the heaviest clumps turn the data. By the Data–Matter Equivalence every clump of matter turns the data round it; the code lets only the heaviest 24 bodies of at least 16 cells do so.
• The fall runs at most one cell a flip. The stated infall speed is v_k = min(c, √(2GM/k)). The code adds v_k to a ring's accumulator each flip but moves the ring's data at most one step inward a flip, taking one unit off (gravity.js:78–80). Where √(2GM/k) is more than one cell a flip, the data falls at one cell a flip, and the rest of the accumulator only grows, until the map is cleared at 40,000 entries.
• The Rupture Rule G. The drains use G_R, not the matter's G_F (Part 4.3).

Fixed numbers