Chapter 3 · Section 3
The Formation Condition in a Scale Model: protoDrawn(), densePlaces(), wellMult
The BPT law
The count of wells a universe forms in its life is the Null Well Progeny Count Law, BPT Part 2.3: N(L) = ℜ_U(L) / ↁℹ∂(V, ℨ) = 2^(L/3). The UniSphere capacity at level L, ℜ_U = 2^L, is a three-bit volume count; the boundary information each well costs, ↁℹ∂, is an area law and scales as ℜ_U^(2/3); the count is what remains, "one spatial third of the capacity." It gives the Zinf universe one child, two from level 3, and 2^(202/3) ≈ 1.86 × 10²⁰ at our level, "against an observed 2 × 10¹⁹ to 10²⁰ stellar-mass Null Wells." The book adds that "spin lowers the area of a well, by half at maximal spin, and so raises the count by at most a factor of two." The code computes this spun law in progenyCount() universe.js:256: N = 2^(L/3) · 2/(1 + √(1 − a_f²)). The comment at universe.js:250–254 calls this "the spin factor the law states in prose: a Kerr well's area is 8πM²(1 + √(1 − a²)), half at maximal spin." How many wells are drawn in a scale model is not a BPT law. BPT does not state this; it is a game method that serves the Progeny Count Law: the drawn wells stand for the law's count, as BPT's "The Count, and the Wells Unseen" (Part 3.14) has the game count its wells "as the sky would."
The established physics
The Kerr horizon area A = 8πM²(1 + √(1 − a²)) in geometric units is standard (Kerr 1963, cited in BPT Chapter 3). The drawn count and its weight are not physics. None: a game method.
The game's math
When the field is drawn at a model level Lm < L, a few thousand drawn wells stand for the true level's count. Three pieces do this.
How many are drawn. protoDrawn(law) app.js:1613 asks the Saturation Law (Part 9.2, saturate() app.js:1610, new in 8.4) how many of the law's wells the field's room can show:
T = max(1, ⌊rows·cols / 4⌋) room for one well per 2 × 2 cells
u = ln(1 + law/T) Fechner: what the eye registers of law wells in a room of T
N = max(1, min(round(law), round(T) − max(1, round(T / (1 + u)))))
A small law is drawn nearly whole; every larger law draws more, and the drawn count approaches the room T without ever filling it. In 8.3 the curve was T·(1 − e^(−law/T)), which reached the whole room in whole wells; 8.4's comment (app.js:1607) records that the new law keeps 8.3's counts where 8.3 was right. An older rule for the drawn count, wellCap() app.js:1601, max(1, min(400, ⌊rows·cols/64⌋)), is still defined; a grep of every game .js file finds only its definition.
Where. densePlaces(k) app.js:1621 finds the k densest places:
- Block side B: 4 normally, 2 if k > rows·cols/64, 1 if k > rows·cols/16. On a field smaller than 16 a side, B = 1.
- Count the pulsing cells per block, then smooth over 3 × 3 neighbors, as in Part 3.2.
- Tie-break. Each block's smoothed count gains a fraction under one, 0.999 · h/2³², where h is an FNV-1a hash of the block's own bits (lit and pulsing) and its index, finished by a murmur-style mix. Equal density is broken by the information the data holds, not by where the block sits (2026-10-27: "all the wells and everything seems to collect on the equatorial lines"). This ordering is
sel. - Take local maxima of
sel(no 8-neighbor higher), densest first, at least two blocks apart (no other taken place in the 3 × 3 around), up to k. - If fewer than k peaks exist, fill with the next densest blocks not yet taken.
- Each place is moved to the centroid of the pulsing cells in its 3 × 3 block window, with mass = sm (the smoothed count), at least 1.
What each stands for. At the Data Nova (app.js:5314–5316):
peaks = densePlaces(protoDrawn(uni.progeny)) if Lm < L
= densestPeaks() otherwise
wellMult = max(1, uni.progeny / peaks.length) if Lm < L, else 1
wellWeight() app.js:1991 returns uni.wellMult (or 1). Each Proto Well registered adds wellWeight() to wellsStand.
Worked case: level 28, desktop, a_f = 0. Lm = 6, so the field is 4·2⁶ = 256 cells a side and rows·cols = 65,536, giving T = 16,384. law = 2^(28/3) = 645.08, u = ln(1 + 645.08/16,384) = 0.03862, and N = 16,384 − round(16,384/1.03862) = 16,384 − 15,775 = 609. If densePlaces finds 609 places, wellMult = 645.08/609 = 1.059. On a phone (Lm = 4, 64 cells a side, T = 1,024): u = 0.4886, N = 1,024 − 688 = 336 and wellMult = 1.920. With spin a_f = 0.998, the law grows by 2/(1 + √(1 − 0.998²)) = 1.881, to 1,213, and a desktop draws 1,093.
Level 202, desktop, a_f = 0. law = 2^(202/3) = 1.859 × 10²⁰, u = 37.07, N = 16,384 − 432 = 15,952, wellMult = 1.166 × 10¹⁶. Each drawn Proto Well stands for about 10¹⁶ wells.
The method, in plain steps:
how many wells to draw: the Saturation Law of the law's count in a room of T = cells / 4
u ← ln(1 + law / T); drawn ← T − round(T / (1 + u)), at most the law itself
where: the k densest blocks, local peaks at least two blocks apart, ties broken by a hash of the data they hold
what each stands for: wellMult ← law / drawn
The code:
// public/game-v8.4/app.js:1610 saturate()
function saturate(x, V) { if (!(x > 0)) return 0; if (!(V > 1)) return 1; const u = Math.log1p(x / V); return Math.max(1, Math.min(Math.round(x), Math.round(V) - Math.max(1, Math.round(V / (1 + u))))); }
// public/game-v8.4/app.js:1613 protoDrawn()
function protoDrawn(law) { const T = Math.max(1, Math.floor((rows * cols) / 4)); return Math.max(1, saturate(Math.max(1, law || 1), T)); }
// public/game-v8.4/app.js:1621 densePlaces()
function densePlaces(k) {
const B = rows >= 16 && cols >= 16 ? (k > (rows * cols) / 16 ? 1 : k > (rows * cols) / 64 ? 2 : 4) : 1, GR = Math.floor(rows / B), GC = Math.floor(cols / B); /* blocks of two cells when more wells are wanted than 4 × 4 blocks have room for (2026-10-29) */
const cnt = new Float64Array(GR * GC), sm = new Float64Array(GR * GC);
for (let r = 0; r < GR * B; r++) for (let c = 0; c < GC * B; c++) if (pulserGrid[r][c]) cnt[Math.floor(r / B) * GC + Math.floor(c / B)]++;
const at = (i, j) => (((i % GR) + GR) % GR) * GC + (((j % GC) + GC) % GC);
for (let i = 0; i < GR; i++) for (let j = 0; j < GC; j++) { let t = 0; for (let a = -1; a <= 1; a++) for (let b = -1; b <= 1; b++) t += cnt[at(i + a, j + b)]; sm[i * GC + j] = t; }
/* ⚠️ WHERE THE DENSITY TIES, THE DATA'S PATTERN DECIDES (8.3, 2026-10-27, the author: "all the wells and everything seems to
collect on the equatorial lines"; measured: at a deep level's Data Nova the data fills every place but the throat's
ring, so every block ties, and the ties went by position, from row 0: the seeds filled in from the outer equator
down). Each block's count gains a fraction under one, a hash of its own bits (lit or not), so equal density is
broken by the information the data holds, not by where the block sits, and the seeds scatter over all of it. */
const sel = new Float64Array(GR * GC);
for (let q = 0; q < sel.length; q++) {
const i0 = Math.floor(q / GC) * B, j0 = (q % GC) * B; let h = 2166136261 ^ q;
for (let r = i0; r < i0 + B; r++) for (let c = j0; c < j0 + B; c++) { h ^= (grid[r][c] ? 1 : 0) | (pulserGrid[r][c] ? 2 : 0); h = Math.imul(h, 16777619); }
h = Math.imul(h ^ (h >>> 15), 2246822507) >>> 0;
sel[q] = sm[q] + 0.999 * (h / 4294967296);
}
const idx = [...sm.keys()].filter(q => sm[q] > 0).sort((x, y) => sel[y] - sel[x]);
const peak = (q) => { const i = Math.floor(q / GC), j = q % GC; for (let a = -1; a <= 1; a++) for (let b = -1; b <= 1; b++) if ((a || b) && sel[at(i + a, j + b)] > sel[q]) return false; return true; };
const taken = [], occ = new Uint8Array(GR * GC), far = (q, d) => { const i = Math.floor(q / GC), j = q % GC; for (let a = -(d - 1); a <= d - 1; a++) for (let b = -(d - 1); b <= d - 1; b++) if (occ[at(i + a, j + b)]) return false; return true; }; /* an occupancy grid: the spacing test was every taken place for every candidate, k² (2026-10-29) */
for (const q of idx) { if (taken.length >= k) break; if (peak(q) && far(q, 2)) { taken.push(q); occ[q] = 1; } }
for (const q of idx) { if (taken.length >= k) break; if (!occ[q]) { taken.push(q); occ[q] = 1; } }
return taken.map(q => {
const bi = Math.floor(q / GC), bj = q % GC;
let wr = 0, wc = 0, wn = 0;
for (let a = -B; a < 2 * B; a++) for (let b = -B; b < 2 * B; b++) { const rr = ((bi * B + a) % rows + rows) % rows, cc = ((bj * B + b) % cols + cols) % cols; if (pulserGrid[rr][cc]) { wr += a; wc += b; wn++; } }
return { r: wn ? ((Math.round(bi * B + wr / wn) % rows) + rows) % rows : bi * B + (B >> 1), c: wn ? ((Math.round(bj * B + wc / wn) % cols) + cols) % cols : bj * B + (B >> 1), mass: Math.max(1, sm[q]) };
});
}
In the game
At the Data Nova of a deep universe (the default level 28 and every level past the drawn one), the torus fills at once with Proto Wells: hundreds on a phone, up to about sixteen thousand on a desktop, each a breathing magenta ring round a violet core, all in one point layer so a thousand cost no more than ten (scene3d.js:1612–1619). They sit at the densest places of the drawn data, not on a grid. The HUD well line, labeled "Proto Wells" between the Data Nova and the Physical Nova, reads in a scale model N counted · n drawn · law X, Y short at level L (or "unseen" once the law passes a million), with counted the true-level count wellsStand and drawn the marks on screen (app.js:2146–2148). Its tooltip says: "Null wells the data has formed so far, and what the Null Well Progeny Count Law expects; the law is compared, never imposed" (index.php:85). The Lineage panel (🪐 Lineage) says the same in a sentence: "Wells formed so far: N (n drawn); the law expects X in its life." The HUD level line adds "drawn at C cells across" when the field is a scale model (app.js:2150). The spin set in the drawer's collision channel raises the law the line shows.
The scale model
Drawn: N ≤ T Proto Wells, placed where the drawn data is densest. Real: uni.progeny wells at level L. One drawn Proto Well stands for wellMult = law ÷ drawn. The weight applies only to Proto Wells (and to wells born at a nova before the Physical Nova, and to fold Proto Wells). A collapse well after the Physical Nova counts as one (Part 3.8). A stellar well counts as starMult.
Where the game and the theory differ
- The comment at app.js:5308–5312 says the Progeny Count Law "is never imposed". In a scale model the number of places asked of
densePlaces()isprotoDrawn(uni.progeny), and wellMult = law ÷ drawn, so the Proto Wells registered at the Data Nova add exactly the law towellsStandwheneverdensePlaces()finds the places it was asked for. At full scale the count is the data's own; in a scale model the law sets the count of Proto Wells and the data sets only where they are. The count read at the End of the Outward Expansion still differs from the law, because failures, sites and collapse wells change it afterward.
Fixed numbers
| Number | Where | What it is | Kind |
|---|---|---|---|
| 1/4 (rows·cols/4) | protoDrawn() app.js:1607 |
T, the room for drawn wells: 1,024 on a phone, 16,384 on a desktop | CAP (the drawn count saturates at it; a device-set room) |
| 1 | app.js:1607 | floors on T, law and N | METHOD (guards; at least one well drawn) |
| 400, 1/64 | wellCap() app.js:1601 |
old cap on drawn wells | CAP (dead code: never called) |
| 16 | densePlaces() app.js:1622 |
least side for blocks larger than one cell | METHOD (resolution) |
| 1/16, 1/64 | app.js:1622 | when to shrink blocks to 1 or 2 cells | METHOD (resolution: enough blocks for k wells) |
| 4, 2, 1 | app.js:1622 | block side choices | METHOD (resolution) |
| −1…1 | app.js:1626, 1634 | 3 × 3 smoothing and peak test | METHOD (stencil) |
| 2166136261, 16777619 | app.js:1634–1635 | FNV-1a offset basis and prime | METHOD (hash) |
| 1, 2 | app.js:1635 | bit codes for lit and pulsing | METHOD (hash input) |
| 2246822507, 15 | app.js:1636 | murmur-style finalizer | METHOD (hash mixing) |
| 0.999 | app.js:1637 | tie-break fraction, under one | METHOD (breaks ties without passing a real difference of one cell) |
| 2³² (4294967296) | app.js:1637 | hash to [0, 1) | METHOD |
| 2 | far(q, 2) app.js:1642 |
least spacing of peaks, in blocks | METHOD (keeps a peak from sitting next to another) |
| B >> 1 | app.js:1647 | block middle fallback | METHOD (geometry) |
| 1 | app.js:1647 | least mass, one cell | BPT (one Zinf quantum, Part 1.8) |
| 3 (L/3) | progenyCount() universe.js:257 |
the progeny law's exponent | BPT (Null Well Progeny Count Law, Part 2.3) |
| 2, 1 | spinAreaFactor() universe.js:261 |
Kerr area factor 2/(1 + √(1 − a²)) | PHYSICS (Kerr horizon area; Kerr 1963) |
| 1 | wellMult app.js:5316 |
least weight of a drawn well | METHOD (a drawn well stands for at least itself) |
Measured
- "level 15 drew 374 against a law of 45" (comment app.js:5314, 2026-10-27). This was the reason for drawing never more than the law.
- "proto wells 920 and only 64 drawn" (ruling quoted at app.js:1602, 2026-10-29). The room was ⌊rows·cols/16⌋ by mistake (256 on a phone) until that date.