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 black holes." 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:1607:

T = max(1, ⌊rows·cols / 4⌋)          room for one well per 2 × 2 cells
N = max(1, min(round(law), round(T · (1 − e^(−law/T)))))

A small law is drawn whole. At law = T, 63 % of it is drawn. Far past T, the drawn count approaches T. The share drawn, N/law, falls smoothly and never at a cut (ruling of 2026-10-29: "there should be a larger threshold than that and the % should scale to the threshold"). 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, and protoDrawn() replaced it.

Where. densePlaces(k) app.js:1615 finds the k densest places:

1. 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.
2. Count the pulsing cells per block, then smooth over 3 × 3 neighbors, as in Part 3.2.
3. 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.
4. 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.
5. If fewer than k peaks exist, fill with the next densest blocks not yet taken.
6. 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:5277–5279):

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:1985 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. N = round(16,384 · (1 − e^(−645.08/16,384))) = round(632.55) = 633. If densePlaces finds 633 places, wellMult = 645.08/633 = 1.019. On a phone (Lm = 4, 64 cells a side, T = 1,024): N = round(478.60) = 479 and wellMult = 1.347. With spin a_f = 0.998, the law grows by 2/(1 + √(1 − 0.998²)) = 1.881.

Level 202, desktop, a_f = 0. law = 2^(202/3) = 1.859 × 10²⁰. N = T = 16,384, wellMult = 1.135 × 10¹⁶. Each drawn Proto Well stands for about 10¹⁶ wells.

In the game

At the Data Nova of a deep universe (the default level 25 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:2140–2142). 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:2144). 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:5271–5275 says the Progeny Count Law "is never imposed". In a scale model the number of places asked of densePlaces() is protoDrawn(uni.progeny), and wellMult = law ÷ drawn, so the Proto Wells registered at the Data Nova add exactly the law to wellsStand whenever densePlaces() 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 final well still differs from the law, because failures, sites and collapse wells change it afterward.

Fixed numbers

Measured

• "level 15 drew 374 against a law of 45" (comment app.js:5277, 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.