- {line.map((token, ti) => {
- const tp = getTokenProps({token}) as any;
- return {tp.children};
- })}
-
- );
- })}
-
- )}
-
-
- <>
-
-
-}
-
export const PaperThumbnail = (
{size, header, ...props}: PaperProps & { size?: { width: number, height: number } }
) => {
diff --git a/orbitmines.com/src/lib/post/Thumbnail.tsx b/orbitmines.com/src/lib/post/Thumbnail.tsx
new file mode 100644
index 00000000..79a7a51e
--- /dev/null
+++ b/orbitmines.com/src/lib/post/Thumbnail.tsx
@@ -0,0 +1,65 @@
+import {useSearchParams} from "react-router-dom";
+
+import ORGANIZATIONS, {PLATFORMS} from "../organizations/ORGANIZATIONS";
+import {PROFILES} from "../../routes/profiles/profiles";
+import {CanvasContainer} from "../../routes/archive/2023.OnOrbits";
+import {
+ BlueprintIcons16, BlueprintIcons20, JetBrainsMono, PaperProps, PaperThumbnail, useCounter,
+} from "./Post";
+
+/**
+ * The social-card page — `/thumbnail`, rendered to an image and never read.
+ *
+ * It lives here rather than in `Post.tsx` for one reason: its header is a
+ * `CanvasContainer`, and that is three.js, react-three-fiber and drei — a
+ * three-megabyte dependency reached by exactly this one page. Named inside
+ * `Post.tsx` it was named by every paper that imports `Post`, which is all of
+ * them, and each of them downloaded a WebGL renderer to draw an article.
+ *
+ * Nothing about the page changed in moving it. What changed is who pays for it.
+ */
+export const ThumbnailPage = () => {
+ const [params] = useSearchParams();
+
+ const title = params.get('title') ?? 'OrbitMines - Stream';
+ const subtitle = params.get('subtitle') ?? '';
+ const date = params.get('date') ?? new Date().toISOString().split('T')[0];
+
+ const referenceCounter = useCounter();
+
+ const paper: Omit
+
+ <>
+
+
+}
+
+export default ThumbnailPage;
diff --git a/orbitmines.com/src/lib/post/highlight.tsx b/orbitmines.com/src/lib/post/highlight.tsx
new file mode 100644
index 00000000..0c30d60c
--- /dev/null
+++ b/orbitmines.com/src/lib/post/highlight.tsx
@@ -0,0 +1,33 @@
+import {Highlight, Prism, themes} from "prism-react-renderer";
+
+/**
+ * A code block, coloured — and the only thing on the site that needs a parser.
+ *
+ * `prism-react-renderer` ships the tokenizer and its grammars, some eighty
+ * kilobytes, and most papers here have no code in them at all. `Post` loads
+ * this module from the first block that is actually drawn (see `highlight`),
+ * so a page without code never asks for it and a page with code shows the
+ * source unstyled for the moment it takes to arrive.
+ */
+const Highlighted = ({code}: {code: string}) => (
+ // @ts-ignore
+
+ {line.map((token, ti) => {
+ const tp = getTokenProps({token}) as any;
+ return {tp.children};
+ })}
+
+ );
+ })}
+
+ )}
+ + So here goes. +
+ Emergence. That's the topic at play here. The question is: "How do you recover gravity and electromagnetism from local interactions?". I personally wanted a discrete model of physics I could point to which had such properties, and so birthed this idea. +
+ Specifically, the idea would be the universe's tendency to exhibit XOR behavior on several scales. This is at least how I came to this idea. Two separate examples would be magnetism, and charged matter. In both cases: Opposites attract, Sameness repells. Hence my naming it XOR. +
+ The model is essentially this idea taken to an extreme. But it is important to note that the theory for gravity is (mostly) independent on that for magnetism, but later in the magnetism section, they will be equivalenced by means of XOR. +
+ I will later expand on those ideas to bring them to full fruition, but for now, let's get started with gravity. + +
+ (G/1) Annihilation: When two rays meet, they annihilate, leaving a single neutral spatial point behind. + +
+ + The model doesn't assume a scale at which these rules should apply. This is important: It would say that there can be discretisation effects if you did assume a scale. And those could be very real based on which frame you chose exactly. + +
+ + For this reason, and the added incapability of our contemporary computers for the necessary scale, there is not actually a discrete 'lattice-like' model which we run. Instead we define the rules as discrete rules, and extrapolate from them a continuous version. But it is important to not forget: This will always be an approximation. Scale-invariance will break once you pick your frame. +
+ + The rules would give us a 'why' to the physics we see. (I will explore actual possible discrete configurations at a later date in a separate arc/section.) + +
+ + Then there's the way a ray propegates through space, its movement rule: + +
+ + (G/c) Movement: [] propagates always at
+ + (G/S.1) Emission: A source has free rein on whether, and on which spatial connections to neighbours it activates a ray, every tick of the universe. + +
+ + (G/S.v) Movement: A source has free rein on whether to move, or to stand still, every tick of the universe. + +
+ + And the other is how often. Which is why at the very least, mass would be proportional to often one emits a ray. We can give this quantity a name. How often a particular direction is activated by the source. Each direction (whether dynamically allocated or not), has this property. It's a number between 0 and
+ + The important pieces to understand being
+ + Though this would be a useful measure of mass, which necessarily depends on the surrounding space, it doesn't quite fit with intuition of what we assume mass to be. Which is why there's the following definition also, which we'll tend to use. By assuming that we have gravity at an instant at infinite range. (Note that this measure of mass does come with the assumption that the spatial structure surrounding the mass is somewhat irrelevant) + +
+ + The model does make a single restriction on the freedoms given to a source. Which is if you move in some direction at some tick in the universe, you cannot also emit a ray in that direction. Likely, in an accurate physics model, you wouldn't emit in any direction (though I'll explore that idea in a subsequent post later). Which is like saying, if you're always moving (light), you cannot also let the universe know you have mass (in that direction). + +
+ + Which means at the very least, there's a tradeoff between 'emitting mass' and velocity (at least in the direction of movement). For the full equation of what that tradeoff will look like, we'd need some notion of what 'not moving nor emitting mass' means - which is kind of an artifact of having the abstraction of sources in our model. For now though, I let the
+ + Alrighty, now we have all the building blocks to properly dive into the continuous setup. + +
+ +
+ +
+ +
+ +
+ + One thing is very clear, we at least need some concept of something analogous to a diagonal. If we just had a perfect lattice as our space. No diagonal would actually cost less movement than just crossing the sides of the triangle. + +
+ + One view would be: There's a propegation direction, but the ray sometimes wanders from diagonal to non-diagonal and back to a diagonal: attempting some forward-preference. This 'wandering' would result in cones in each direction, with relative deadzones on the boundaries of them. + +
+ + This was the original idea on which I built the continuous model (Kind of assuming I'd be able to create a circle), but I've since realized a better second option: + +
+ + Namely if we consider vacuum dynamics. In the pure gravity setting (so discounting the magnetism part which we haven't gotten to yet: XOR), we don't have vacuum dynamics other than just expansion of a space. See for instance the following example of how space would expand because of the creation rule if nothing is nearby: + +
+
+ + (Where that lands: the electromagnetic sections argue that the derived half puts the mean free path at about two cells, and that a Coulomb force with a range of two Planck lengths is not a Coulomb force. That argument is now the one to answer. An earlier draft of this paragraph reported the measured path as three to seven cells "depending on the theory and the rate" and concluded that the vacuum's density was a free parameter after all, which the observed range of electrostatics could then bound. There is no rate, so there is no such freedom: the density is a half because half the meetings are alike, and the constraint lands where it first did.) + + and then annihilation turns out to FEED the expansion, which is the loop the two rules make + +
+ +
+ +
+ +
+ +
+
+
+ + It turns out that this is all the machinary we need to derive gravitational laws that approximate
+ + Let's dive into the continuous model to show you how. + +
+ +
+ + + +
+ + TODO Rewrite everything past this point: + + + +
+ + +
+ + How we would get a model which knows where to move from local interactions I don't yet know (that'll be something for the future). But for now we can just calculate a trajectory based on the space. + +
+ + one pulse, spread — which is where the inverse square is + + +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+
+
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ (G+M/1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind. + +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ + +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ [10,0,0]|J| =
+ [20,0,0]|J| =
+
+ ∠(E, B) =
+ +
+ +
+ +
the sources that most obviously have magnetic fields +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+
+
+ so per-turn ΔE/E must be under
+ so
+ so
+ and
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+
+ +
+ +
+ +
+
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+
+ +
+
+
+
+ what is derived
+
+ + +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ + And the honest way to check that is to run it rather than to admire it. Same rules, no orbital mechanics anywhere, only bodies letting go of charges and charges meeting. + +
+ + And the same rule with three bodies in it, which is where I stopped expecting anything and got the known closed solutions back anyway. + +
+ +
+ +
+ +
+ +
+
+
+
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+
+
+ +
+ +
+ +
+ +
+ +
+ +
+
+ +
+ +
+
+ +
+ +
+ +
+
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
sided ? along() : cos(2πβ), and + +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ + and it is not a third rule — the lattice already emits it + +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ +
+ ╰c╯╰──── middle ────╯╰c╯ + }> + Inside
+
;
+};
+
+/**
+ * WHAT THIS IS WAITING FOR.
+ *
+ * The figures that most need it — `Beam` and `Sheet`, the two pictures that are
+ * about the lattice rather than about what happens on it — are drawn through the
+ * archive's `GraphCanvas`: a real graph patch with a camera, connections and the
+ * same grey for space that has not been charged by anything. A reader who has been
+ * looking at those for ten screens should not have to work out whether a new one is
+ * the same kind of thing, so generalising them means feeding THAT renderer from a
+ * geometry rather than drawing something else beside it.
+ *
+ * A first attempt drew flat vector diagrams instead and they were a different figure
+ * wearing the same caption, which is worse than not having generalised them. So the
+ * renderer is what has to be ported, and this is here ready for it.
+ */
diff --git a/orbitmines.com/src/routes/Physics/visuals/CURVE.tsx b/orbitmines.com/src/routes/Physics/visuals/CURVE.tsx
new file mode 100644
index 00000000..60fa31be
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/CURVE.tsx
@@ -0,0 +1,110 @@
+/**
+ * A ROTATION CURVE, UNDER BOTH LAWS — Newton falling away, and the same baryons
+ * through the transport rule staying flat.
+ *
+ * WHAT IT IS A CURVE OF, stated because it matters: an EXPONENTIAL DISC, which is the
+ * standard idealisation of a spiral galaxy and not a fit to any particular one. The
+ * article's Milky Way figures use a measured baryonic model and quote ratios against
+ * Gaia; reproducing those needs that model, and inventing one here to get a curve that
+ * looked right would be the opposite of the point. What this shows is the MECHANISM:
+ * the same mass, the same radii, one law that falls and one that does not.
+ *
+ * NOTHING IS FITTED IN THE SECOND CURVE. a₀ = cH₀/2π comes out of the expansion rate,
+ * and the interpolation is what the turnover condition solves to — both checked in
+ * `cosmology/rotation`, which shares this exact code through `TRANSPORT.ts`.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { Carousel, Slide } from "./CAROUSEL";
+import { A0_MEASURED, G_NEWTON, H0, KPC, MSUN, a0, gOf } from "../TRANSPORT";
+
+const BACK = "#08090d";
+const FAINT = "#5a5f6e", INK = "#c6c9d4";
+const CYAN = "#3ddcff", AMBER = "#ff7a45";
+
+/**
+ * AN EXPONENTIAL DISC: Σ(R) = Σ₀ e^(−R/Rd), so the mass inside R is
+ * M(R) = 2πΣ₀Rd² [1 − (1 + R/Rd) e^(−R/Rd)].
+ */
+const enclosed = (R: number, Mtot: number, Rd: number) =>
+ Mtot * (1 - (1 + R / Rd) * Math.exp(-R / Rd));
+
+type Model = { name: string; Mtot: number; Rd: number; says: string };
+
+const DISCS: Model[] = [
+ { name: "a spiral like ours", Mtot: 6e10 * MSUN, Rd: 3 * KPC,
+ says: "6·10¹⁰ M☉ in an exponential disc of scale length 3 kpc" },
+ { name: "a tenth the mass", Mtot: 6e9 * MSUN, Rd: 1.5 * KPC,
+ says: "6·10⁹ M☉ at 1.5 kpc — thinner, so the turnover comes in sooner" },
+];
+
+const draw = (m: Model) => (s: Surface) => {
+ const { ctx, width, height } = s;
+ ctx.clearRect(0, 0, width, height);
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+ const L = 46, R = 14, T = 14, B = 30;
+ const w = width - L - R, h = height - T - B;
+ const A = a0(H0.planck);
+
+ const RMAX = 30 * KPC;
+ const pts = Array.from({ length: 240 }, (_, i) => {
+ const r = ((i + 1) / 240) * RMAX;
+ const gN = (G_NEWTON * enclosed(r, m.Mtot, m.Rd)) / (r * r);
+ return {
+ r: r / KPC,
+ newton: Math.sqrt(gN * r) / 1000, // km/s
+ model: Math.sqrt(gOf(gN, A) * r) / 1000,
+ };
+ });
+ const VMAX = Math.max(...pts.map(p => p.model)) * 1.15;
+
+ const X = (r: number) => L + (r / (RMAX / KPC)) * w;
+ const Y = (v: number) => T + h - (v / VMAX) * h;
+
+ // axes
+ ctx.strokeStyle = FAINT; ctx.lineWidth = 1;
+ ctx.beginPath(); ctx.moveTo(L, T); ctx.lineTo(L, T + h); ctx.lineTo(L + w, T + h); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.font = "10px system-ui, sans-serif";
+ ctx.textAlign = "right";
+ for (const v of [50, 100, 150, 200, 250]) {
+ if (v > VMAX) continue;
+ ctx.fillText(String(v), L - 6, Y(v) + 3);
+ ctx.strokeStyle = "rgba(90,95,110,0.22)";
+ ctx.beginPath(); ctx.moveTo(L, Y(v)); ctx.lineTo(L + w, Y(v)); ctx.stroke();
+ }
+ ctx.textAlign = "center";
+ for (const r of [5, 10, 15, 20, 25, 30]) ctx.fillText(String(r), X(r), T + h + 14);
+ ctx.fillText("radius (kpc)", L + w / 2, T + h + 26);
+ ctx.save();
+ ctx.translate(11, T + h / 2); ctx.rotate(-Math.PI / 2);
+ ctx.fillText("v (km/s)", 0, 0);
+ ctx.restore();
+
+ const curve = (key: "newton" | "model", colour: string, dash: number[]) => {
+ ctx.strokeStyle = colour; ctx.lineWidth = 1.6; ctx.setLineDash(dash);
+ ctx.beginPath();
+ pts.forEach((p, i) => (i ? ctx.lineTo(X(p.r), Y(p[key])) : ctx.moveTo(X(p.r), Y(p[key]))));
+ ctx.stroke(); ctx.setLineDash([]);
+ };
+ curve("newton", AMBER, [4, 4]);
+ curve("model", CYAN, []);
+
+ ctx.textAlign = "left";
+ ctx.fillStyle = AMBER; ctx.fillText("Newton, the same baryons", L + 10, T + 14);
+ ctx.fillStyle = CYAN; ctx.fillText("the transport rule", L + 10, T + 28);
+ ctx.fillStyle = FAINT;
+ ctx.fillText(`a₀ = cH₀/2π = ${A.toExponential(2)} m/s² · nothing fitted`,
+ L + 10, T + h - 8);
+};
+
+const view = (m: Model) =>
+
+ {arrow(-1, "←")}{arrow(1, "→")}
+ {slides[at]?.label}
+
+ {slides.map((s, i) => {i === at ? "●" : "·"})}
+
+
+
+ {/* the track: every slide side by side, moved as one so the change reads as a step
+ between two things rather than as one picture being replaced by another */}
+
+
+
+ {slides.map((s, i) =>
+
+ {/* only what is on screen is built; a slide two steps away is an empty box,
+ which is what keeps a page of these affordable */}
+ {Math.abs(i - at) <= 1 ? s.render() : null}
+
)}
+
+
;
+
+// ─── Genzel's discs ─────────────────────────────────────────────────────────
+
+/**
+ * GENZEL ET AL. 2017, NATURE 543:397 — TABLE 1, VERBATIM.
+ *
+ * SIX GALAXIES, NOT FIVE. The archive's copy dropped D3a 15504 and carried gas
+ * fractions and radii that are not the published columns. What is here is
+ * `Mbaryon(gas+stars, including bulge)` and `R1/2(n=1)` — the two the model needs —
+ * with `fDM(R1/2)` and its published ±2σ uncertainty or upper limit.
+ *
+ * AND f_DM IS MEASURED PER GALAXY, which changes what this panel can be. The old
+ * version drew one ceiling at 0.2 for all of them, because that is what the abstract
+ * says. The table gives each galaxy its own number with its own error, so the model is
+ * testable object by object — and since f_DM IS the free fraction, the prediction is
+ * 1/(1+θ) with nothing free in it.
+ */
+type HighZ = { name: string; z: number; Mb: number; Re: number; f: number; e: number; limit: boolean };
+
+/** Mb in 1e11 M☉ including bulge; Re = R1/2(n=1) kpc; f = fDM(R1/2), e = ±2σ or limit */
+const DISCS: HighZ[] = [
+ { name: "COS4 01351", z: 0.854, Mb: 1.7, Re: 7.3, f: 0.21, e: 0.10, limit: false },
+ { name: "D3a 6397", z: 1.500, Mb: 2.3, Re: 7.4, f: 0.17, e: 0.38, limit: true },
+ { name: "GS4 43501", z: 1.613, Mb: 1.0, Re: 4.9, f: 0.19, e: 0.09, limit: false },
+ { name: "zC 406690", z: 2.196, Mb: 1.7, Re: 5.5, f: 0.00, e: 0.08, limit: true },
+ { name: "zC 400569", z: 2.242, Mb: 1.7, Re: 3.3, f: 0.00, e: 0.07, limit: true },
+ { name: "D3a 15504", z: 2.383, Mb: 2.1, Re: 6.0, f: 0.12, e: 0.26, limit: true },
+];
+
+/** the baryonic acceleration at R1/2, in units of a₀ — the only input the model needs */
+const depthOf = (d: HighZ, a0: number) =>
+ G * d.Mb * 1e11 * MSUN / Math.pow(d.Re * KPC, 2) / a0;
+
+/**
+ * WHAT THE MODEL PREDICTS FOR EACH: f_DM = the free fraction = 1/(1+θ), nothing fitted.
+ * Five of six are consistent with the published value. `zC 406690` is not — predicted
+ * 0.106 against a measured 2σ upper limit of 0.08 — and it is drawn as a miss rather
+ * than absorbed into a band.
+ */
+const predict = (d: HighZ, a0: number) => {
+ const gN = depthOf(d, a0) * a0;
+ return 1 / (1 + (gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0)) / a0);
+};
+const consistent = (d: HighZ, a0: number) => {
+ const p = predict(d, a0);
+ return d.limit ? p <= d.e : Math.abs(p - d.f) <= d.e;
+};
+const boostAt = (x: number) => Math.sqrt(transport(x, 1) / x);
+
+/**
+ * AND THE CURVE ON THIS PANEL IS THE DERIVED ONE, which is worth saying because it
+ * looks like MOND's and is not borrowed from it.
+ *
+ * `transport` solves g = g_N(1 + a₀/g). That equation is not picked for its shape: it
+ * is what a vacuum that cannot expand where matter already is has to do. A point
+ * carrying a charge is busy — an arriving charge annihilates or reverses, and either
+ * way that point does not split this tick — so splitting is suppressed exactly where
+ * the field is strong. With θ = g/a₀ the free fraction is 1/(1+θ), the busy fraction
+ * θ/(1+θ) is g_N/g, and rearranging gives g² − g·g_N − g_N·a₀ = 0. Checked across six
+ * decades of g_N/a₀, θ/(1+θ) and g_N/g agree to the last digit at every point.
+ *
+ * So the boost each disc is judged by, and the depth at which the law breaches the
+ * ceiling, are both consequences of the expansion mechanism rather than of a fitted
+ * interpolation — which is what makes the Genzel comparison a test of THIS model.
+ *
+ * THE PANEL IS ABOUT A THRESHOLD, NOT A COUNT.
+ *
+ * The archive's version plotted boost against redshift and read off "four of five
+ * overshoot", which is an adjective. What `cosmology/high-redshift-discs` measures is
+ * that f_DM < 0.2 fixes a CEILING on the boost and the transport law breaches it only
+ * BELOW a derivable depth — g_N/a₀ = 3.2 — so each disc is judged on a measurable
+ * property of itself rather than on which side of a tally it falls. That number and
+ * the ceiling are both read from the report, so the vertical line and the horizontal
+ * one move if the run does.
+ */
+const discs = (s: Surface) => {
+ const { ctx } = s;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, s.width, s.height);
+ const box = frame(s, 52, 46); // room for the f_DM axis on the right
+ const ceil = CEILING(), breach = BREACH(), a0 = A0();
+
+ const XMIN = 0.5, XMAX = 40; // g_N/a₀, logarithmic
+ const X = (v: number) => box.x0 + box.w *
+ (Math.log(v) - Math.log(XMIN)) / (Math.log(XMAX) - Math.log(XMIN));
+ const YMIN = 1.0, YMAX = 1.62; // room for the ±2σ bars, which reach f_DM ≈ 0.55
+ const Y = (v: number) => box.y1 - box.h * (v - YMIN) / (YMAX - YMIN);
+
+ ctx.font = "400 10px ui-monospace, Menlo, monospace";
+ ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+ for (const t of [1.0, 1.1, 1.2, 1.3, 1.4]) {
+ ctx.beginPath(); ctx.moveTo(box.x0, Y(t)); ctx.lineTo(box.x1, Y(t)); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "right";
+ ctx.fillText(t.toFixed(2), box.x0 - 6, Y(t) + 3);
+ }
+ for (const t of [1, 2, 5, 10, 20, 40]) {
+ ctx.beginPath(); ctx.moveTo(X(t), box.y0); ctx.lineTo(X(t), box.y1); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "center";
+ ctx.fillText(String(t), X(t), box.y1 + 15);
+ }
+ ctx.textAlign = "left";
+
+ // everything above the ceiling is refused by the measurement
+ if (Number.isFinite(ceil)) {
+ ctx.fillStyle = EXCL; ctx.fillRect(box.x0, box.y0, box.w, Y(ceil) - box.y0);
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 1.6; ctx.setLineDash([5, 4]);
+ ctx.beginPath(); ctx.moveTo(box.x0, Y(ceil)); ctx.lineTo(box.x1, Y(ceil)); ctx.stroke();
+ ctx.setLineDash([]);
+ }
+
+ // and the depth at which the law crosses it — the test's own derived threshold
+ if (Number.isFinite(breach)) {
+ ctx.strokeStyle = DATA; ctx.lineWidth = 1.4; ctx.setLineDash([2, 3]);
+ ctx.beginPath(); ctx.moveTo(X(breach), box.y0); ctx.lineTo(X(breach), box.y1); ctx.stroke();
+ ctx.setLineDash([]);
+ }
+
+ // Newton, who predicts no boost at all
+ ctx.strokeStyle = RELAT; ctx.lineWidth = 1.8;
+ ctx.beginPath(); ctx.moveTo(box.x0, Y(1)); ctx.lineTo(box.x1, Y(1)); ctx.stroke();
+
+ // the transport law across depth
+ ctx.strokeStyle = MODEL; ctx.lineWidth = 2.4;
+ ctx.beginPath();
+ for (let i = 0; i <= 240; i++) {
+ const x = XMIN * Math.pow(XMAX / XMIN, i / 240);
+ const y = Y(Math.min(YMAX, boostAt(x)));
+ if (i === 0) ctx.moveTo(X(x), y); else ctx.lineTo(X(x), y);
+ }
+ ctx.stroke();
+
+ /*
+ * EACH GALAXY TWICE: where the model says it should be, and where Genzel measured
+ * it. The bar is the published ±2σ, or an arrow down from an upper limit. A galaxy
+ * whose prediction lands inside its own bar is green; one that does not is red, and
+ * there is one of those.
+ */
+ if (Number.isFinite(a0)) for (const d of DISCS) {
+ const x = depthOf(d, a0), p = predict(d, a0);
+ const ok = consistent(d, a0);
+ const bx = X(x);
+ const bY = (f: number) => Y(1 / Math.sqrt(1 - Math.min(f, 0.9)));
+
+ // the measurement, with its own error
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 1.3;
+ if (d.limit) {
+ ctx.beginPath(); ctx.moveTo(bx, bY(d.e)); ctx.lineTo(bx, bY(0)); ctx.stroke();
+ ctx.beginPath();
+ ctx.moveTo(bx, bY(0)); ctx.lineTo(bx - 3, bY(0) - 5); ctx.moveTo(bx, bY(0));
+ ctx.lineTo(bx + 3, bY(0) - 5); ctx.stroke();
+ ctx.beginPath(); ctx.moveTo(bx - 4, bY(d.e)); ctx.lineTo(bx + 4, bY(d.e)); ctx.stroke();
+ } else {
+ ctx.beginPath();
+ ctx.moveTo(bx, bY(Math.max(0, d.f - d.e))); ctx.lineTo(bx, bY(d.f + d.e)); ctx.stroke();
+ for (const q of [Math.max(0, d.f - d.e), d.f + d.e]) {
+ ctx.beginPath(); ctx.moveTo(bx - 4, bY(q)); ctx.lineTo(bx + 4, bY(q)); ctx.stroke();
+ }
+ ctx.fillStyle = SEEN;
+ ctx.beginPath(); ctx.arc(bx, bY(d.f), 2.4, 0, 7); ctx.fill();
+ }
+
+ // and the prediction
+ ctx.fillStyle = ok ? FLOORC : "#e0685f";
+ ctx.beginPath(); ctx.arc(bx, bY(p), 4.2, 0, 7); ctx.fill();
+ ctx.strokeStyle = BACK; ctx.lineWidth = 1.2; ctx.stroke();
+
+ ctx.fillStyle = FAINT;
+ ctx.font = "400 8px ui-monospace, Menlo, monospace";
+ ctx.save();
+ ctx.translate(bx + 6, bY(p) - 7); ctx.rotate(-Math.PI / 4);
+ ctx.fillText(d.name, 0, 0); ctx.restore();
+ }
+
+ const nOK = Number.isFinite(a0) ? DISCS.filter(d => consistent(d, a0)).length : 0;
+ tag(s, box.x0 + 8, Y(1.40),
+ `${nOK} of ${DISCS.length} predictions land inside Genzel's own ±2σ — white is measured, dot is predicted`,
+ nOK === DISCS.length ? FLOORC : SEEN);
+ /*
+ * THE FREE FRACTION IS NOT A SECOND CURVE, BECAUSE IT IS NOT A SECOND FACT.
+ *
+ * A first version drew it alongside the boost on its own 0…1 axis, which made two
+ * lines out of one statement: boost = 1/√(1 − free), exactly, at every point. Two
+ * curves that are deterministic functions of each other read as corroboration and
+ * are not — a reader comparing them learns nothing the algebra did not already fix.
+ *
+ * AND THE IDENTITY IS SHARPER THAN THAT. f_DM is defined by boost = 1/√(1 − f_DM),
+ * and the mechanism gives boost = 1/√(1 − free). So
+ *
+ * f_DM = free fraction = 1/(1 + θ) exactly, checked to 1e-12
+ *
+ * The dark-matter fraction a telescope measures IS the share of the vacuum still
+ * able to expand. Genzel's f_DM(
+ the Milky Way's rotation, against Eilers 2019's own 38 points and their published
+ errors. Newton on the baryons alone is χ²/point 5178; the transport law with a₀
+ read live from the run brings it to 8.2 — a real improvement and NOT a good fit
+
+
+ ({ frame: (s: Surface) => rotation(s) })} />
+
+
+
;
+
+// ─── the radial acceleration relation ───────────────────────────────────────
+
+/**
+ * THE RAR — 2,693 POINTS, 153 GALAXIES, AND A LAW WITH NOTHING FITTED IN IT.
+ *
+ * McGaugh, Lelli & Schombert 2016 (PRL 117:201101) plotted the observed centripetal
+ * acceleration against the one the baryons alone predict, for every rotationally
+ * supported galaxy they had. It is the tightest empirical statement about the missing
+ * gravity, and it is the right thing to point this model at because the model has no
+ * freedom here at all: the shape is the blocked expansion, the scale is cH₀/2π.
+ *
+ * WHAT IS DRAWN AND WHERE IT COMES FROM:
+ *
+ * the dotted diagonal g_obs = g_bar, which is Newton — no missing gravity anywhere
+ * the white points SPARC itself, all 2,696 of them, from Lelli+2016's catalogue
+ * the white curve McGaugh+2016's fitting function, fitted to those points
+ * the blue curve this model, g = g_N(1 + a₀/g), a₀ read live from the report
+ *
+ * AND THE POINTS ARE THE WHOLE POINT. This panel used to draw a ±0.11 dex band around
+ * their fit and report that the model sat inside it — a comparison between two
+ * formulae, dressed as a comparison with the sky. The residual that matters is the one
+ * against the measurements, and it is 0.1333 dex against 0.1327 for the two-parameter
+ * curve fitted to exactly these points. A law with nothing free in it is five
+ * ten-thousandths of a dex behind the best summary the data admit.
+ */
+const G_DAGGER = 1.20e-10;
+const rarFit = (gb: number) => gb / (1 - Math.exp(-Math.sqrt(gb / G_DAGGER)));
+
+/**
+ * WHAT THE FITTED CURVE SCORES ON THE SAME POINTS, measured here rather than read.
+ *
+ * It is the one number in the panel that is not the model's and cannot come out of
+ * the report: `cosmology/sparc` quotes it in a note, and a note is prose. Two lines of
+ * arithmetic over the same array give it directly, and having both computed the same
+ * way is what makes 0.1333 against 0.1327 a comparison rather than two numbers.
+ */
+const theirRms = () => {
+ let ss = 0;
+ for (const p of RAR) ss += Math.log10(p.gobs / rarFit(p.gbar)) ** 2;
+ return Math.sqrt(ss / RAR.length);
+};
+
+const rarPanel = (s: Surface) => {
+ const { ctx } = s;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, s.width, s.height);
+ const box = frame(s, 54, 18);
+ const a0 = A0();
+ const LO = -12.2, HI = -8.0; // log g_bar
+ const VLO = -12, VHI = -7.6; // log g_obs
+ const X = (L: number) => box.x0 + box.w * (L - LO) / (HI - LO);
+ const Y = (L: number) => box.y1 - box.h * (L - VLO) / (VHI - VLO);
+
+ ctx.font = "400 10px ui-monospace, Menlo, monospace";
+ ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+ for (let L = -12; L <= -8; L++) {
+ ctx.beginPath(); ctx.moveTo(X(L), box.y0); ctx.lineTo(X(L), box.y1); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "center";
+ ctx.fillText(String(L), X(L), box.y1 + 15);
+ }
+ for (let L = -12; L <= -8; L++) {
+ ctx.beginPath(); ctx.moveTo(box.x0, Y(L)); ctx.lineTo(box.x1, Y(L)); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "right";
+ ctx.fillText(String(L), box.x0 - 6, Y(L) + 3);
+ }
+ ctx.textAlign = "left";
+
+ const S: number[] = [];
+ for (let L = LO; L <= HI; L += 0.02) S.push(L);
+
+ /*
+ * THE POINTS THEMSELVES, WHICH IS WHAT CHANGED HERE.
+ *
+ * An earlier version of this panel drew a BAND of ±0.11 dex around McGaugh et al.'s
+ * fitted curve and said the model sat inside it. That compared two formulae and
+ * called the agreement a result: a fit is a summary whose residuals have already
+ * been thrown away, and a curve tracking another curve has not met a galaxy. What
+ * is drawn now is SPARC's own 2,696 measurements — every one of them, reduced from
+ * the catalogue's rotation curves and Spitzer photometry by the published recipe —
+ * and the residual quoted below is against those, not against the summary.
+ */
+ ctx.fillStyle = "rgba(238,240,245,0.16)";
+ for (const p of RAR) {
+ ctx.beginPath();
+ ctx.arc(X(Math.log10(p.gbar)), Y(Math.log10(p.gobs)), 1.15, 0, 2 * Math.PI);
+ ctx.fill();
+ }
+
+ // Newton: no missing gravity at all
+ ctx.strokeStyle = RELAT; ctx.lineWidth = 1.4; ctx.setLineDash([4, 4]);
+ ctx.beginPath(); ctx.moveTo(X(LO), Y(LO)); ctx.lineTo(X(HI), Y(HI)); ctx.stroke();
+ ctx.setLineDash([]);
+
+ // their fit, and this model
+ const draw = (f: (gb: number) => number, col: string, w: number, dash: number[] = []) => {
+ ctx.strokeStyle = col; ctx.lineWidth = w; ctx.setLineDash(dash);
+ ctx.beginPath();
+ S.forEach((L, i) => {
+ const y = Y(Math.log10(f(Math.pow(10, L))));
+ if (i === 0) ctx.moveTo(X(L), y); else ctx.lineTo(X(L), y);
+ });
+ ctx.stroke(); ctx.setLineDash([]);
+ };
+ draw(rarFit, SEEN, 2.0);
+ if (Number.isFinite(a0)) draw(gb => transport(gb, a0), MODEL, 2.2, [6, 3]);
+
+ tag(s, X(-12.1), Y(-8.0), `measured — SPARC, ${RAR.length} points in 147 galaxies, every one drawn`, SEEN);
+ tag(s, X(-12.1), Y(-8.22), "Lelli+2016's catalogue, reduced by McGaugh+2016's own recipe", FAINT);
+ if (Number.isFinite(a0)) {
+ const rms = SPARC_RMS(), ratio = SPARC_A0();
+ tag(s, X(-12.1), Y(-8.5), `THIS MODEL — g = g_N(1 + a₀/g), a₀ = ${a0.toExponential(3)} m/s², nothing fitted`, MODEL);
+ tag(s, X(-12.1), Y(-8.72), Number.isFinite(rms)
+ ? `rms ${rms.toFixed(4)} dex FROM THE POINTS — against ${theirRms().toFixed(4)} for the curve fitted to them`
+ : "rms FROM THE POINTS — NOT IN THE REPORT", Number.isFinite(rms) ? MODEL : "#e0685f");
+ if (Number.isFinite(ratio))
+ tag(s, X(-12.1), Y(-8.94), `and a₀ sits ${((1 - ratio) * 100).toFixed(0)}% under the a₀ these points would pick`, FAINT);
+ }
+ tag(s, X(-9.6), Y(-9.9), "NEWTON — nothing missing", RELAT);
+
+ ctx.fillStyle = FAINT;
+ ctx.textAlign = "center";
+ ctx.fillText("log g_bar [m s⁻²] — what the baryons alone predict", (box.x0 + box.x1) / 2, s.height - 8);
+ ctx.textAlign = "left";
+ ctx.fillText("log g_obs", 6, 18);
+};
+
+export const RadialAcceleration = ({ height = 340 }: { height?: number } = {}) =>
+
+ Genzel 2017's six discs against their own published f_DM and ±2σ — the model
+ predicts each from its baryonic depth alone, with nothing fitted. Five land
+ inside; zC 406690 does not
+
+
+ ({ frame: (s: Surface) => discs(s) })} />
+
+
+
;
+
+// ─── the baryonic Tully–Fisher relation ─────────────────────────────────────
+
+/**
+ * ONE HUNDRED AND TWENTY-THREE WHOLE GALAXIES, AND A SLOPE WITH NOTHING IN IT.
+ *
+ * The relation above is measured point by point inside galaxies. This one is measured
+ * galaxy by galaxy: the mass of everything that shines or is cold hydrogen, against
+ * the speed the outermost gas is going round at, for every SPARC disc whose rotation
+ * curve reaches a flat part. It is a different measurement of a different thing, and
+ * the model's prediction for it is a single number that cannot be adjusted.
+ *
+ * deep in the transport regime g → √(g_N a₀)
+ * so V⁴ = G·M_b·a₀ SLOPE 4, EXACTLY
+ * and A = 1/(G a₀) a normalisation with no freedom either
+ *
+ * WHAT THE PANEL DRAWS, AND WHY ONE LINE IS A CEILING RATHER THAN A PREDICTION.
+ *
+ * The blue line is A = 1/(G a₀) at slope 4 — where galaxies would sit if V_f were the
+ * asymptotic speed. It is not: V_f is measured where the telescope ran out of gas, and
+ * the transport law sits ABOVE its own asymptote everywhere, so the real V_f exceeds
+ * the asymptotic one and every galaxy must fall UNDER that line. All 123 do, by 0.173
+ * dex in the mean, and the outermost radii SPARC actually reached predict a gap of
+ * 0.125 — the same size, in the same direction, with the residual difference well
+ * inside the ±0.1 dex the stellar mass-to-light ratio carries on its own.
+ *
+ * So the honest reading is: the SLOPE is the test and it is nearly passed (3.73 here,
+ * 3.85 ± 0.09 by Lelli et al.'s maximum likelihood, against a predicted 4, with their
+ * own systematic covering 3.5 to 4.0); the NORMALISATION is a one-sided consistency
+ * check and it is consistent. The panel says which is which rather than drawing both
+ * as though they were the same kind of claim.
+ */
+const tullyFisher = (s: Surface) => {
+ const { ctx } = s;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, s.width, s.height);
+ const box = frame(s, 52, 16);
+ const a0 = A0();
+
+ const XLO = 1.25, XHI = 2.6; // log V_f, km/s
+ const YLO = 7.0, YHI = 11.9; // log M_b, M☉
+ const X = (v: number) => box.x0 + box.w * (v - XLO) / (XHI - XLO);
+ const Y = (v: number) => box.y1 - box.h * (v - YLO) / (YHI - YLO);
+
+ ctx.font = "400 10px ui-monospace, Menlo, monospace";
+ ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+ for (let L = 7; L <= 11; L++) {
+ ctx.beginPath(); ctx.moveTo(box.x0, Y(L)); ctx.lineTo(box.x1, Y(L)); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "right";
+ ctx.fillText(String(L), box.x0 - 6, Y(L) + 3);
+ }
+ for (const v of [20, 50, 100, 200, 300]) {
+ const L = Math.log10(v);
+ ctx.beginPath(); ctx.moveTo(X(L), box.y0); ctx.lineTo(X(L), box.y1); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "center";
+ ctx.fillText(String(v), X(L), box.y1 + 15);
+ }
+ ctx.textAlign = "left";
+
+ const { x, y } = btfrAxes();
+
+ /*
+ * THE CEILING: slope four through A = 1/(G a₀).
+ *
+ * A first version shaded the whole region above it, the way the Genzel panel shades
+ * what f_DM refuses. It is the wrong figure for that: the ceiling runs off the
+ * bottom-left corner, so "above it" is most of the frame and the eye reads a red
+ * field with the data cowering under it rather than a line nothing crosses. A strip
+ * along the line says the same thing and says it where the reader is looking.
+ */
+ if (Number.isFinite(a0)) {
+ const c = Math.log10(btfrCeiling(a0));
+ const at = (L: number) => Y(4 * L + c);
+ ctx.fillStyle = EXCL;
+ ctx.beginPath();
+ ctx.moveTo(X(XLO), at(XLO)); ctx.lineTo(X(XHI), at(XHI));
+ ctx.lineTo(X(XHI), at(XHI) - 26); ctx.lineTo(X(XLO), at(XLO) - 26);
+ ctx.closePath(); ctx.fill();
+ ctx.strokeStyle = MODEL; ctx.lineWidth = 2.2;
+ ctx.beginPath(); ctx.moveTo(X(XLO), at(XLO)); ctx.lineTo(X(XHI), at(XHI)); ctx.stroke();
+ }
+
+ /* and the same slope four carried down to where the galaxies actually are */
+ const at4 = x.map((v, i) => y[i] - 4 * v);
+ const logA = at4.reduce((a, b) => a + b, 0) / at4.length;
+ ctx.strokeStyle = FLOORC; ctx.lineWidth = 1.6; ctx.setLineDash([5, 4]);
+ ctx.beginPath();
+ ctx.moveTo(X(XLO), Y(4 * XLO + logA)); ctx.lineTo(X(XHI), Y(4 * XHI + logA));
+ ctx.stroke(); ctx.setLineDash([]);
+
+ /* the orthogonal fit the data themselves prefer, which is what the slope claim is about */
+ const fit = orthogonalFit(x, y);
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 1.4;
+ ctx.beginPath();
+ ctx.moveTo(X(XLO), Y(fit.slope * XLO + fit.intercept));
+ ctx.lineTo(X(XHI), Y(fit.slope * XHI + fit.intercept));
+ ctx.stroke();
+
+ /* every galaxy, with the error on its flat velocity */
+ for (const g of BTFR) {
+ const L = Math.log10(g.vf), M = Math.log10(baryonicMass(g) / MSUN);
+ ctx.strokeStyle = "rgba(238,240,245,0.35)"; ctx.lineWidth = 1;
+ ctx.beginPath();
+ ctx.moveTo(X(Math.log10(Math.max(1, g.vf - g.e))), Y(M));
+ ctx.lineTo(X(Math.log10(g.vf + g.e)), Y(M));
+ ctx.stroke();
+ ctx.fillStyle = SEEN;
+ ctx.beginPath(); ctx.arc(X(L), Y(M), 1.9, 0, 2 * Math.PI); ctx.fill();
+ }
+
+ const slope = BTFR_SLOPE(), gap = BTFR_GAP();
+ tag(s, X(1.30), Y(11.55), `measured — SPARC, all ${BTFR.length} galaxies with a flat rotation velocity`, SEEN);
+ if (Number.isFinite(a0))
+ tag(s, X(1.30), Y(11.20), "THE CEILING — slope 4 at A = 1/(G a₀), and no galaxy may sit above it", MODEL);
+ tag(s, X(1.30), Y(10.85), Number.isFinite(gap)
+ ? `where they do sit — the same slope 4, ${gap.toFixed(3)} dex under the ceiling`
+ : "where they do sit — THE GAP IS NOT IN THE REPORT", Number.isFinite(gap) ? FLOORC : "#e0685f");
+ tag(s, X(1.30), Y(10.50), Number.isFinite(slope)
+ ? `and the slope the points prefer — ${slope.toFixed(2)}, against a predicted 4`
+ : "and the slope the points prefer — NOT IN THE REPORT", Number.isFinite(slope) ? SEEN : "#e0685f");
+ tag(s, X(1.72), Y(7.35), "V_f is where the gas ran out, not infinity — so the gap is required, and one-sided", FAINT);
+
+ ctx.fillStyle = FAINT;
+ ctx.textAlign = "center";
+ ctx.fillText("flat rotation velocity V_f [km/s] (SPARC, borrowed)",
+ (box.x0 + box.x1) / 2, s.height - 8);
+ ctx.textAlign = "left";
+ ctx.fillText("log M_baryons [M☉]", 6, 18);
+};
+
+export const TullyFisher = ({ height = 340 }: { height?: number } = {}) =>
+
+ the radial acceleration relation — SPARC's own 2,696 measured points against a
+ curve with no free parameter in it, which fits them as well as the curve fitted
+ to them does
+
+
+ ({ frame: (s: Surface) => rarPanel(s) })} />
+
+
+
;
diff --git a/orbitmines.com/src/routes/Physics/visuals/EXPAND.tsx b/orbitmines.com/src/routes/Physics/visuals/EXPAND.tsx
new file mode 100644
index 00000000..3440a854
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/EXPAND.tsx
@@ -0,0 +1,270 @@
+/**
+ * THE EXPANSION, ONE TICK AT A TIME — the split shown slowly enough to read.
+ *
+ * This is the article's original expansion animation, restored, and corrected to what
+ * the model actually does. The phased shape is the thing worth keeping: a continuous
+ * tick-over shows a lattice getting bigger and explains nothing, where four stages of
+ * ONE tick — the charges going out, where they met, what is left — is the rule itself.
+ *
+ * WHAT IS DIFFERENT FROM THE ORIGINAL, and it matters. That version had the halves
+ * meet at the NEIGHBOURING POINT, because its lattice had only integer positions to
+ * put them on. The rule inserts a point BETWEEN two others and the two halves meet on
+ * the shared edge, so the meeting is at the MIDPOINT — and that is not a detail:
+ *
+ * INSIDE both halves of the inserted point arrive, they annihilate, the point
+ * collapses, and the lattice is exactly as it was. Two became one where
+ * one had become two. NET NOTHING, which is why the bulk is static.
+ * AT THE EDGE the outward half has nothing to meet. It is never given back, and
+ * THAT POINT IS NEW SPACE. Which is the whole of why a boundary grows
+ * while an interior does not.
+ *
+ * So the bright midpoints are annihilations and the lone ones are the frontier, and
+ * the picture makes the same distinction the cosmology arc turns on.
+ *
+ * AND IT IS A FUNCTION OF THE GEOMETRY. The exits a point splits along are the
+ * geometry's, so the figure runs across all of them rather than showing cubic 26 as
+ * though it were the model.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { Carousel, Slide } from "./CAROUSEL";
+import { Geometry, GEOMETRIES, Vec } from "../DISCRETE";
+
+const BACK = "#08090d";
+const GREY = "140,147,168"; // NEUTRAL, as the lattice is drawn
+const SEEN = "#eef0f5";
+
+/** one pulse, in seconds — the original's timing, which reads at a glance */
+const OUT = 0.62, HIT = 0.14, SETTLE = 0.24;
+const PULSE = OUT + HIT + SETTLE;
+/*
+ * HOW MANY PULSES BEFORE IT STARTS AGAIN — and far fewer in three dimensions, because
+ * the growth is the point of the figure and it is fast. A 3³ patch on cubic 26 goes to
+ * 125 points after one tick and past a thousand after two; by the fourth there is
+ * nothing to see but a solid mass, and every one of those points is drawing 26 arrows.
+ * The line can afford to run longer because it grows by two points a tick.
+ */
+const PULSES_1D = 5, PULSES_3D = 3;
+
+type Phase = { travel: number; flash: number; born: number; spent: number };
+const phaseOf = (t: number): Phase => ({
+ travel: Math.min(1, t / OUT),
+ flash: t >= OUT && t < OUT + HIT ? 1 - (t - OUT) / HIT : 0,
+ born: t < OUT + HIT ? 0 : Math.min(1, (t - OUT - HIT) / SETTLE),
+ spent: Math.min(1, t / OUT),
+});
+
+const key = (p: number[]) => p.map(x => Math.round(x * 2)).join(",");
+
+/**
+ * ONE TICK OF THE SPLIT, as positions.
+ *
+ * Every point splits along every exit; each half lands on the MIDPOINT of that edge.
+ * A midpoint reached from both ends has its two halves annihilate and collapses; one
+ * reached from a single end is on the frontier and survives as new space.
+ */
+const split = (alive: Vec[], g: Geometry) => {
+ const met = new Map
+ the baryonic Tully–Fisher relation — 123 SPARC galaxies, a predicted slope of
+ exactly 4, and a normalisation the model can only put a ceiling on
+
+
+ ({ frame: (s: Surface) => tullyFisher(s) })} />
+
+
+
;
+
+const ORDER = [
+ "cubic-26", "cubic-18", "fcc-12", "bcc-8", "cubic-6", "square-8", "triangular-6",
+];
+
+export const Expanding = ({ height = 260 }: { height?: number } = {}) =>
+
+ {view(LINE, true)}
+
+
+ {/*
+ * EVERY JUDGED FINDING, INCLUDING THE ONES THAT DID NOT RESOLVE.
+ *
+ * This used to keep only findings with a finite value, which sounds like tidying
+ * and is not: a quantity the run could not measure is exactly the one a reader
+ * needs told about, and three of them — among them the force exponent under both
+ * gravity theories, which is the whole of `gravity/inverse-square` — were failing
+ * their expectation and being dropped from the page for it. A marker line with no
+ * value (a note, a tier stamp) still has nothing to show and is still skipped.
+ */}
+
;
+};
+
+/** what the whole suite found, which is the one place to see the shape of it */
+export const Matrix = () => {
+ const ids = [...new Set(REPORT_TYPED.entries.map(e => e.id.split(" · ")[0]))];
+ const theories = [...new Set(REPORT_TYPED.entries.map(e => e.id.split(" · ")[1]).filter(Boolean))];
+ const cell = (id: string, th: string) => {
+ const e = entryOf(`${id} · ${th}`);
+ if (!e) return "—";
+ if (e.findings.some(f => f.name === "not applicable")) return "n/a";
+ const judged = e.findings.filter(f => f.verdict);
+ if (!judged.length) return "—";
+ if (judged.every(f => f.verdict === "within")) return "holds";
+ return judged.some(f => f.verdict && f.verdict !== "within" && f.verdict !== "unresolved")
+ ? "outside" : "unresolved";
+ };
+ const w = Math.max(...ids.map(i => i.length)) + 2;
+ return
+ {"".padEnd(w) + theories.map(t => t.padEnd(20)).join("")}{"\n"}
+ {ids.map(id => id.padEnd(w) + theories.map(t => cell(id, t).padEnd(20)).join("")).join("\n")}
+ ;
+};
diff --git a/orbitmines.com/src/routes/Physics/visuals/LATTICE.tsx b/orbitmines.com/src/routes/Physics/visuals/LATTICE.tsx
new file mode 100644
index 00000000..aceb00e6
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/LATTICE.tsx
@@ -0,0 +1,341 @@
+/**
+ * THE TWO PICTURES THAT ARE ABOUT THE LATTICE rather than about what happens on it.
+ *
+ * One is what a step costs — a cell a tick, which is the whole of c̄. The other is
+ * what a sheet is: the exits a source pulses into, and the ring they come round on.
+ *
+ * THEY ARE DRAWN THE WAY THE REST OF THE LATTICE PICTURES ARE, deliberately: real
+ * points with their connections between them, the same grey for space that has not
+ * been charged by anything, the same cyan and amber for the two polarities, seen
+ * through the same kind of camera. A reader who has been looking at those for ten
+ * screens should not have to work out whether a new one is the same kind of thing.
+ *
+ * WHAT IS NEW IS THAT THEY ARE FUNCTIONS OF A GEOMETRY. A geometry is a parameter of
+ * this model and not a fact about it, so a picture drawn on cubic 26 alone is a
+ * picture of one reading — and the differences are not cosmetic. A step is 1, √2 or
+ * √3 long on cubic 26 and a single length on FCC, which IS the light-speed
+ * anisotropy; a sheet is eight exits on cubic, six on FCC, and NOTHING AT ALL on
+ * BCC, which is why charge as this book writes it could not exist there.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { Carousel, Slide } from "./CAROUSEL";
+import { Geometry, GEOMETRIES, Vec, add, dot, norm, scale, unit } from "../DISCRETE";
+
+// the article's own palette, so these sit beside the other lattice pictures
+export const BACK = "#08090d";
+export const NEUTRAL = [140, 147, 168], CYAN = [61, 220, 255], AMBER = [255, 122, 69];
+export const rgba = (c: number[], a: number) => `rgba(${c[0]}, ${c[1]}, ${c[2]}, ${a})`;
+
+/** how far along its connection a boundary is drawn, so the two ends meet with a gap */
+export const STUB = 0.42;
+
+export type Cam = { yaw: number; pitch: number; scale: number; cx: number; cy: number };
+
+/** the same orbit camera the lattice views use: yaw, then pitch, then flatten */
+export const place = (v: Vec, cam: Cam) => {
+ const [x, y, z] = [v[0] ?? 0, v[1] ?? 0, v[2] ?? 0];
+ const cy = Math.cos(cam.yaw), sy = Math.sin(cam.yaw);
+ const cp = Math.cos(cam.pitch), sp = Math.sin(cam.pitch);
+ const rx = x * cy - z * sy;
+ const rz = x * sy + z * cy;
+ const ry = y * cp - rz * sp;
+ const depth = y * sp + rz * cp;
+ return { x: cam.cx + rx * cam.scale, y: cam.cy - ry * cam.scale, depth };
+};
+
+/** the points of a patch: every lattice position within `half` of the middle */
+export const patch = (g: Geometry, half: number): Vec[] => {
+ const out: Vec[] = [];
+ const walk = (p: number[]) => {
+ if (p.length === g.D) { out.push(p.slice()); return; }
+ for (let i = -half; i <= half; i++) walk([...p, i]);
+ };
+ walk([]);
+ return out;
+};
+
+/**
+ * A STRIP: long the way the thing is going, thin across it.
+ *
+ * A beam wants a strip and not a cube. Drawn in a 7³ block the ray is one point among
+ * three hundred and forty-three and cannot be picked out at all — which is a picture
+ * of a lattice with something lost in it rather than a picture of something crossing
+ * a lattice.
+ */
+export const strip = (g: Geometry, length: number, across: number): Vec[] => {
+ const out: Vec[] = [];
+ const walk = (p: number[]) => {
+ if (p.length === g.D) { out.push(p.slice()); return; }
+ const h = p.length === 0 ? length : across;
+ for (let i = -h; i <= h; i++) walk([...p, i]);
+ };
+ walk([]);
+ return out;
+};
+
+/**
+ * The connections, drawn as two stubs with a gap between them — which is what a
+ * BOUNDARY is here. A point does not touch its neighbour; each holds its own way
+ * out, and the gap is where nothing is.
+ *
+ * Only single steps are drawn. Anything longer is a connection that has closed up
+ * over space annihilated out from between its ends: real, and the reason the ends
+ * are near each other, but not an event, and drawing it puts a growing web of bright
+ * lines over the picture that reads as things happening everywhere at once.
+ */
+export const connections = (
+ ctx: CanvasRenderingContext2D, g: Geometry, points: Vec[], cam: Cam,
+ alpha = 0.22,
+) => {
+ const has = new Set(points.map(p => p.join(",")));
+ ctx.lineWidth = 1;
+ ctx.strokeStyle = rgba(NEUTRAL, alpha);
+ ctx.beginPath();
+ for (const p of points) {
+ for (let d = 0; d < g.DEG; d++) {
+ const q = add(p, g.V[d]);
+ if (!has.has(q.map(v => Math.round(v)).join(","))) continue;
+ const a = place(p, cam), b = place(q, cam);
+ ctx.moveTo(a.x, a.y);
+ ctx.lineTo(a.x + (b.x - a.x) * STUB, a.y + (b.y - a.y) * STUB);
+ }
+ }
+ ctx.stroke();
+};
+
+export const nodes = (
+ ctx: CanvasRenderingContext2D, points: Vec[], cam: Cam,
+ colour: (p: Vec) => number[] | undefined, r = 2.4, alpha = 1,
+) => {
+ const drawn = points
+ .map(p => ({ p, at: place(p, cam) }))
+ .sort((a, b) => a.at.depth - b.at.depth);
+ for (const { p, at } of drawn) {
+ const c = colour(p);
+ if (!c) continue;
+ const near = Math.min(Math.max((at.depth + 3) / 6, 0.35), 1);
+ ctx.beginPath();
+ ctx.arc(at.x, at.y, r * near, 0, Math.PI * 2);
+ ctx.fillStyle = rgba(c, (0.5 + 0.45 * near) * alpha);
+ ctx.fill();
+ }
+};
+
+/*
+ * NOTHING IS WRITTEN INSIDE THE PICTURE. What a figure is of belongs beside it, in
+ * the same type as the prose, where it can be read — and a caption drawn into a
+ * canvas is a caption that cannot be selected, searched or resized with the rest of
+ * the page. The carousel's own label carries the geometry and its constants.
+ */
+
+const camFor = (sur: Surface, g: Geometry, span: number, turn = 0): Cam => ({
+ yaw: g.D === 2 ? 0 : 0.62 + turn,
+ pitch: g.D === 2 ? 0 : 0.42,
+ scale: Math.min(sur.width, sur.height - 26) / (1.5 * span),
+ cx: sur.width / 2,
+ cy: (sur.height - 20) / 2 + 6,
+});
+
+// ─── a cell a tick ──────────────────────────────────────────────────────────
+
+/**
+ * SOMETHING TRAVELLING AT THE SPEED OF LIGHT: one cell, one tick.
+ *
+ * Remade every step rather than ticked. Movement in this model is a swap — the mover
+ * eats the point in front and puts a fresh one down behind — and a fresh point has
+ * only the connections it was made with, so a ray ticked across a strip leaves the
+ * row behind it stripped of its transverse connections. That is a true fact about
+ * moving through space and completely the wrong sentence for a diagram that is only
+ * saying `a cell a tick`. So each frame is a fresh patch with the ray one further on.
+ *
+ * AND THE EXIT IT TRAVELS ALONG IS THE GEOMETRY'S LONGEST. On cubic 26 that is a body
+ * diagonal, which covers √3 cells in the tick a face step covers one — so the same
+ * diagram on the same lattice says both `a cell a tick` and `73% further along that
+ * way`, and the second is the thing this book has to answer for.
+ */
+const beam = (g: Geometry) => {
+ const LONG = 5, ACROSS = 2;
+ /*
+ * TWO RAYS, ON THE SHORTEST EXIT AND THE LONGEST, both moving one exit a tick.
+ *
+ * That is the generalisation worth having. On a geometry whose exits are all the
+ * same length they stay level and `a cell a tick` is the whole story; on cubic 26
+ * one of them pulls away from the other by 73% because a body diagonal covers √3
+ * cells in the tick a face step covers one. The same diagram then says both
+ * sentences at once, and the second is the one this book has to answer for.
+ */
+ const shortest = g.steps.indexOf(Math.min(...g.steps));
+ const longest = g.steps.indexOf(Math.max(...g.steps));
+ const same = g.cAnisotropy < 1.001;
+ let at = 0;
+ return (sur: Surface) => {
+ const { ctx } = sur;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, sur.width, sur.height);
+ const cam = camFor(sur, g, 2 * LONG + 1);
+ const pts = strip(g, LONG, ACROSS);
+ connections(ctx, g, pts, cam);
+
+ const k = at++ % (2 * LONG + 1);
+ const rays = same ? [shortest] : [shortest, longest];
+ const on = new Map
+ {e.findings.filter(f => (f.value != null && isFinite(f.value)) || f.verdict).map(f =>
+ `${f.name.padEnd(38)}${fmt(f.value, 5)}${typeof f.err === "number" && isFinite(f.err) ? ` ± ${fmt(f.err, 2)}` : ""}` +
+ `${f.verdict ? ` ${f.verdict === "within" ? "within"
+ : f.verdict === "unresolved" ? "DID NOT RESOLVE"
+ : `${f.verdict} by ${(100 * (f.by ?? 0)).toFixed(1)}%`}` : ""}`
+ ).join("\n")}
+
+ {e.table ?
+
,
+ g => g.SHEET
+ ? `SHEET ${g.SHEET} · CYCLE ${g.CYCLE} · SPIN ${(360 / g.CYCLE).toFixed(0)}° — still, then turning`
+ : "SHEET 0 — no ring, so no phase and no charge could exist here")} />;
diff --git a/orbitmines.com/src/routes/Physics/visuals/LINES.tsx b/orbitmines.com/src/routes/Physics/visuals/LINES.tsx
new file mode 100644
index 00000000..4e99e29c
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/LINES.tsx
@@ -0,0 +1,384 @@
+/**
+ * THE SMALL UNIVERSES — every arrangement of two charges on a line, run.
+ *
+ * These are the cases where the whole of what can happen can be LISTED rather than
+ * sampled. Two points, each carrying either polarity, each going either way: sixteen
+ * arrangements before the symmetries are taken out, and none of them chosen.
+ *
+ * WHAT MAKES IT WORTH REDRAWING. The archive's version enumerated the same states and
+ * then applied its own reading of the rules to them. These run `DISCRETE.ts` — a real
+ * `World` on the registered `line-2` geometry, one tick of the real collide rule — so
+ * what the strip shows is the outcome the model gives rather than the outcome the
+ * figure was told to draw. If the rules change, these change with them.
+ *
+ * AND BOTH DIRECTIONS OF TIME. (G/1) and (G/2) are exact inverses — annihilation is
+ * creation run backwards — so the same strip read right to left with every heading
+ * reversed is the other rule. That is why the article draws it both ways rather than
+ * drawing creation separately.
+ *
+ * GREY, NOT AMBER AND CYAN, in the gravity arc. Polarity is introduced later, and the
+ * whole claim of the magnetism arc is that adding it to THESE runs is what makes the
+ * difference — so a picture that colours the two kinds from the start answers that
+ * before it has been asked.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import {
+ Charge, GEOMETRIES, GRAVITY_MAGNETISM, World,
+} from "../DISCRETE";
+
+const BACK = "#08090d";
+const GREY = "140,147,168", CYAN = "61,220,255", AMBER = "255,122,69";
+
+type Side = { q: 1 | -1; dir: 0 | 1 }; // dir 0 = +1 (right), 1 = −1 (left)
+
+/** every arrangement of n charges in a row: either polarity, either way */
+const linesOf = (n: number): Side[][] =>
+ n === 0 ? [[]] : linesOf(n - 1).flatMap(rest =>
+ ([[1, 0], [1, 1], [-1, 0], [-1, 1]] as const).map(([q, dir]) =>
+ [{ q, dir } as Side, ...rest]));
+
+/** read back to front with every heading reversed — the same experiment from the far end */
+const mirrored = (l: Side[]): Side[] =>
+ [...l].reverse().map(s => ({ q: s.q, dir: (s.dir ? 0 : 1) as 0 | 1 }));
+
+const read = (l: Side[]) => l.map(s => `${s.q}${s.dir}`).join(",");
+const key = (l: Side[]) => {
+ const [a, b] = [read(l), read(mirrored(l))];
+ return a < b ? a : b;
+};
+
+/** every polarity flipped, every heading kept: the anti-line */
+const anti = (l: Side[]): Side[] => l.map(s => ({ q: -s.q as 1 | -1, dir: s.dir }));
+
+/** the distinct lines, each paired with its anti-line */
+const groups = (n: number): Side[][][] => {
+ const seen = new Map{view(() => sheet(g, false), false)}
+ {view(() => sheet(g, true), true)}
+
+ {note ?
;
+};
diff --git a/orbitmines.com/src/routes/Physics/visuals/LORENTZ.tsx b/orbitmines.com/src/routes/Physics/visuals/LORENTZ.tsx
new file mode 100644
index 00000000..18ae76c4
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/LORENTZ.tsx
@@ -0,0 +1,177 @@
+/**
+ * THE LORENTZ FORCE, BY THE TWO MECHANISMS THAT PRODUCE IT — and only one of them
+ * is a circle.
+ *
+ * A magnetic field can bend a path here in two different ways, and the arc spent a
+ * section telling them apart:
+ *
+ * A GATE changes WHICH MEETINGS HAPPEN. The charge is pushed sideways and the
+ * count of meetings ahead of it and behind it stays equal, so the speed is
+ * conserved and the path closes. This is `qv × B` and nothing else.
+ *
+ * A TURN changes WHAT A MEETING DOES. It rotates the pair through the lattice's
+ * own step, and a rotation costs its (1 − cos θ) — so the same bend also drags
+ * ALONG the path. That is a longitudinal force, and a storage ring refutes it.
+ *
+ * Both are drawn from the same start with the same coupling, so the drag is visible
+ * as the turn's path falling inside the gate's.
+ *
+ * WHAT MOVED WHEN THIS WAS PORTED. The drag used to be `(1 − cos 0.055)·3.2`: a
+ * drawing constant times a fudge factor, with no lattice anywhere in it, and the
+ * archive's own note admitted the θ behind its published 0.1511 "matches nothing in
+ * the geometry" — it implies 17.2°, and no lattice has a 17.2° step. The ratio is
+ * now `tan(l.SPIN/2)` off `CONTINUOUS.ts`, which is the identity the article already
+ * derives and tabulates: deviation/coupling = tan(θ/2)/sin θ, at θ = 2π/CYCLE. On
+ * cubic 26 that is the 0.414214 of the article's own table; on the fcc 12 the book
+ * runs on it is the geometry's, and the panel follows it.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { constants } from "../CONTINUOUS";
+
+const FAINT = "#5a5f6e", BACK = "#08090d";
+const MINUS = "#eb964a"; // − polarity, as everywhere else in the book
+const SEEN = "#eef0f5"; // the thing being pointed at
+const FIELD = "#8bd48b"; // the magnetic axis
+
+const k = constants();
+
+/**
+ * HOW MUCH OF THE BEND IS ALSO A DRAG, which is the one number in this panel that
+ * is physics rather than framing.
+ *
+ * `F∥/F⊥ = tan(θ/2)` with θ the lattice's own turn, `l.SPIN = 2π/CYCLE`. It is an
+ * identity rather than a measurement — the transverse coupling goes as sin θ and the
+ * deviation as tan(θ/2), so their ratio is 1/(1 + cos θ) and the 41.4% of an
+ * eighth-turn is a property of the STEP and not of the mechanism. It goes to zero
+ * with θ, and a finer lattice has less of it.
+ */
+const DRAG_RATIO = Math.tan(k.SPIN / 2);
+
+type V = { x: number; y: number };
+const v = (x: number, y: number): V => ({ x, y });
+const addv = (a: V, b: V): V => v(a.x + b.x, a.y + b.y);
+const sclv = (a: V, s: number): V => v(a.x * s, a.y * s);
+const lenv = (a: V) => Math.hypot(a.x, a.y);
+const unitv = (a: V): V => { const n = lenv(a); return n < 1e-9 ? v(0, 0) : sclv(a, 1 / n); };
+
+const label = (sur: Surface, left: string, right: string) => {
+ const { ctx, width, height } = sur;
+ ctx.font = "11px ui-monospace, monospace";
+ ctx.fillStyle = FAINT;
+ ctx.textAlign = "left";
+ ctx.fillText(left, 10, height - 10);
+ ctx.textAlign = "right";
+ ctx.fillText(right, width - 10, height - 10);
+ ctx.textAlign = "left";
+};
+
+const lorentz = (): { start?: () => void; frame: (s: Surface, dt: number) => void } => {
+ type Tr = { p: V; vel: V; path: V[] };
+ let gate: Tr, turn: Tr;
+ let acc = 0;
+
+ /**
+ * FRAMING, not physics: the bend per step and the step length are chosen so that
+ * ONE REVOLUTION FITS THE PANEL, and the walk stops a little past one so both
+ * curves stay legible. An earlier version used a bend of 0.048 rad and a step of
+ * 1.5, which gives a circle of radius 31 units drawn at 0.55 px/unit — seventeen
+ * pixels, inside the marker — and then reset before a second lap. Rendering is the
+ * only way that shows up: it typechecks perfectly.
+ */
+ const BEND = 0.055, STEP = 1.9, SCALE = 1.55;
+ const STEPS = Math.round(1.15 * 2 * Math.PI / BEND);
+
+ /**
+ * Both trajectories are integrated ONCE, up front, rather than a step per frame.
+ * A path that builds at the frame rate is empty in a screenshot and empty for the
+ * first second a reader looks at it, and neither is a property of the physics.
+ */
+ const build = () => {
+ gate = { p: v(0, 0), vel: v(1, 0), path: [v(0, 0)] };
+ turn = { p: v(0, 0), vel: v(1, 0), path: [v(0, 0)] };
+ for (let i = 0; i < STEPS; i++) {
+ {
+ const sp = lenv(gate.vel);
+ const perp = unitv(v(-gate.vel.y, gate.vel.x));
+ gate.vel = sclv(unitv(addv(gate.vel, sclv(perp, BEND * sp))), sp);
+ gate.p = addv(gate.p, sclv(gate.vel, STEP));
+ gate.path.push({ ...gate.p });
+ }
+ {
+ // the same bend, and then the fraction of it the rotation also takes
+ // along the path — which is BEND of turning at tan(θ/2) per unit turned
+ const sp = lenv(turn.vel);
+ const perp = unitv(v(-turn.vel.y, turn.vel.x));
+ const bent = unitv(addv(turn.vel, sclv(perp, BEND * sp)));
+ turn.vel = sclv(bent, sp * (1 - DRAG_RATIO * BEND));
+ turn.p = addv(turn.p, sclv(turn.vel, STEP));
+ turn.path.push({ ...turn.p });
+ }
+ }
+ };
+ build();
+
+ return {
+ start: build,
+ frame: (sur, dt) => {
+ const { ctx, width, height } = sur;
+ const H = height - 26;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+ acc += Math.min(dt, 0.05);
+
+ const mark = Math.floor((acc * 90) % gate.path.length);
+
+ // the field, out of the plane and uniform
+ ctx.fillStyle = "rgba(139,212,139,0.11)";
+ for (let x = 22; x < width; x += 30) for (let y = 64; y < H; y += 30) {
+ ctx.beginPath(); ctx.arc(x, y, 1.9, 0, 7); ctx.fill();
+ }
+
+ // both start at the same place, heading the same way — the circle's centre
+ // sits one radius above the start, so put the start low and left of middle
+ const cx = width / 2 - 40, cy = H - 40;
+ const draw = (tr: Tr, col: string) => {
+ ctx.strokeStyle = col; ctx.lineWidth = 1.8; ctx.globalAlpha = 0.9;
+ ctx.beginPath();
+ tr.path.forEach((p, i) => {
+ const X = cx + p.x * SCALE, Y = cy - p.y * SCALE;
+ if (i === 0) ctx.moveTo(X, Y); else ctx.lineTo(X, Y);
+ });
+ ctx.stroke();
+ ctx.globalAlpha = 1;
+ const m = tr.path[Math.min(mark, tr.path.length - 1)];
+ if (m) {
+ ctx.fillStyle = col;
+ ctx.beginPath();
+ ctx.arc(cx + m.x * SCALE, cy - m.y * SCALE, 3.6, 0, 7); ctx.fill();
+ }
+ };
+ draw(turn, MINUS);
+ draw(gate, FIELD);
+ ctx.fillStyle = SEEN;
+ ctx.beginPath(); ctx.arc(cx, cy, 2.6, 0, 7); ctx.fill();
+
+ ctx.font = "10px ui-monospace, monospace"; ctx.fillStyle = FAINT;
+ ctx.fillText("B out of the plane, uniform · both released from the same point", 12, 18);
+ ctx.font = "11px ui-monospace, monospace";
+ ctx.fillStyle = FIELD; ctx.fillText("gate — speed conserved, the path closes", 12, 36);
+ ctx.fillStyle = MINUS; ctx.fillText("turn — the same bend, and it spirals in", 12, 52);
+
+ label(sur, "both bend the path — only one of them also slows it",
+ `F∥/F⊥ = tan(l.SPIN/2) = ${DRAG_RATIO.toFixed(4)} · ${k.geometry}`);
+ },
+ };
+};
+
+/** the force, and the deviation the arc removed */
+export const Lorentz = ({ height = 340 }: { height?: number }) =>
+ {note}
: null}
+
+ {view(gs, backwards, polarities, did)}
+
+
+
;
diff --git a/orbitmines.com/src/routes/Physics/visuals/NBODY.tsx b/orbitmines.com/src/routes/Physics/visuals/NBODY.tsx
new file mode 100644
index 00000000..49c7c5c4
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/NBODY.tsx
@@ -0,0 +1,65 @@
+/**
+ * THE THREE-BODY CHOREOGRAPHIES, under the model's own force law.
+ *
+ * `NBODY.ts` runs them; this draws them. The point is a negative one and it is the
+ * one worth making: the curves are the SAME as Newton's, because g = g_N(1 + a₀/g)
+ * has a bracket that is one to many digits at these accelerations. A choreography is
+ * a delicate object — the figure-eight closes for one set of initial conditions and
+ * comes apart under a force law that is slightly wrong — so keeping it is a real
+ * check on the bracket rather than a picture of one.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { Carousel, Slide } from "./CAROUSEL";
+import { SOLUTIONS, evolve } from "../NBODY";
+import { a0 } from "../TRANSPORT";
+
+const BACK = "#08090d";
+const TRACK = ["#3ddcff", "#ff7a45", "#c6c9d4"];
+
+const draw = (name: string) => {
+ const sol = SOLUTIONS[name];
+ const steps = 6000, dt = (sol.period * 2) / steps;
+ const model = evolve(sol.bodies, dt, steps, a0());
+ const newton = evolve(sol.bodies, dt, steps, 0);
+ const apart = Math.max(...model.bs.map((b, i) =>
+ Math.hypot(b.x - newton.bs[i].x, b.y - newton.bs[i].y)));
+
+ return (s: Surface) => {
+ const { ctx, width, height } = s;
+ ctx.clearRect(0, 0, width, height);
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+ let R = 0.5;
+ for (const p of model.paths) for (const [x, y] of p) R = Math.max(R, Math.abs(x), Math.abs(y));
+ const k = Math.min(width, height) / (2.4 * R);
+ const cx = width / 2, cy = height / 2;
+
+ model.paths.forEach((path, i) => {
+ ctx.strokeStyle = TRACK[i % TRACK.length];
+ ctx.lineWidth = 1.3; ctx.globalAlpha = 0.85;
+ ctx.beginPath();
+ path.forEach(([x, y], j) =>
+ j ? ctx.lineTo(cx + x * k, cy - y * k) : ctx.moveTo(cx + x * k, cy - y * k));
+ ctx.stroke();
+ ctx.globalAlpha = 1;
+ const b = model.bs[i];
+ ctx.fillStyle = TRACK[i % TRACK.length];
+ ctx.beginPath(); ctx.arc(cx + b.x * k, cy - b.y * k, 3, 0, 2 * Math.PI); ctx.fill();
+ });
+
+ ctx.font = "11px system-ui, sans-serif";
+ ctx.fillStyle = "#5a5f6e"; ctx.textAlign = "left";
+ ctx.fillText(
+ `two periods · furthest any body ends from Newton's: ${apart.toExponential(1)}`,
+ 12, height - 12);
+ };
+};
+
+export const Choreographies = ({ height = 320 }: { height?: number } = {}) =>
+ the Lorentz force, by the two mechanisms that produce it — and only one of them is a circle
+
+
+
+
;
diff --git a/orbitmines.com/src/routes/Physics/visuals/PLAYER.tsx b/orbitmines.com/src/routes/Physics/visuals/PLAYER.tsx
new file mode 100644
index 00000000..8562c15c
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/PLAYER.tsx
@@ -0,0 +1,364 @@
+/**
+ * A LATTICE, TICKING, WITH TRANSPORT CONTROLS — the new core's replacement for the
+ * archive's `LatticePlayer`.
+ *
+ * The old one ran `archive/discrete.ts`, a 3,395-line simulator written before
+ * `DISCRETE.ts` existed and sharing no code with it. So every lattice panel in the
+ * article was showing A DIFFERENT MODEL from the one the tests measure — same
+ * intentions, separately maintained, and nothing anywhere checked that the two agreed.
+ * That is the whole reason for this file: a picture of the model has to be a picture
+ * of THE model.
+ *
+ * IT LOOKS THE SAME ON PURPOSE. Same camera, same palette, same points-and-stubs
+ * drawing as the other lattice figures — a reader ten screens deep should not have to
+ * work out whether a new picture is a new kind of thing. What changed is underneath.
+ */
+
+import { useEffect, useRef, useState } from "react";
+
+import { CanvasView, Surface } from "./CANVAS";
+import { Carousel, Slide } from "./CAROUSEL";
+import {
+ AMBER, BACK, Cam, CYAN, NEUTRAL, connections, nodes, place, rgba,
+} from "./LATTICE";
+import { GEOMETRIES, GRAVITY, GRAVITY_MAGNETISM, Theory, Vec, World, WorldOptions } from "../DISCRETE";
+
+export type Seed = (w: World) => void;
+
+export type PlayerSpec = {
+ /** what the world is: everything `World` takes, plus what to put in it */
+ world: Omit
+ one orbit under three laws, the same integrator throughout — Kepler closes, and
+ general relativity and the annihilation count precess by the same amount to four
+ figures. Which is the classical test passed, and the classical test shown to be
+ unable to separate the two
+
+
+ ({ frame: draw([NEWTON, SCHWARZSCHILD, COUNTED]) })} />
+
+
+ {s.note ?
;
+};
+
+/*
+ * THE SEEDS THE ARTICLE'S LATTICE PANELS USE — two blocks of charge facing each
+ * other, and two emitters across a gap.
+ *
+ * IN TWO DIMENSIONS, as the originals were: `Graph.blocks` and `Graph.emitters` both
+ * set `dims = 2`, and a plane is the right picture for these because the thing being
+ * shown is which way things go, which a 3D block hides behind its own outer shell.
+ * `square-8` is the new core's plane and it is a geometry like any other, so these
+ * pictures come off the same `World` as everything else.
+ */
+
+/*
+ * AND THESE RUN WITH NO VACUUM, which is the setting that makes them pictures at all.
+ *
+ * `expansion` defaults to 1 — every neutral point splits every tick — and under
+ * polarity that fills the whole plane with charge. The two blocks are then a few
+ * points among a thousand and cannot be picked out: measured, the panel is a solid
+ * field of cyan and amber with the sources invisible inside it. The vacuum is a real
+ * part of the model and has its own figures; THESE panels are about what two blocks
+ * do to each other, so they are run in empty space and say so.
+ */
+export const EMPTY = { expansion: 0 } as const;
+
+/**
+ * TWO CLUMPS OF CHARGE THROWN AT EACH OTHER — the whole of (G+M/1) and (G+M/3) in one
+ * picture, and NOTHING ELSE RUNNING.
+ *
+ * It is a demonstration, not a sample, so everything that is not the rule is taken
+ * out. There are no sources: nobody is emitting, nobody is absorbing, and the number
+ * of charges never grows. Two rectangles of rays are simply placed on the lattice,
+ * the left one heading right and the right one heading left, and then the rules are
+ * let run. Expansion is off, so (G+M/2) makes nothing either — what is on the board
+ * at the start is all there will ever be.
+ *
+ * WHY IT IS BUILT THIS WAY. Earlier versions of this figure used `Source` bodies with
+ * momentum, which dragged in the whole of `moveRule`, mass, recoil and a body's force
+ * on itself — and what a reader then saw was two blobs of *emitted field* grazing past
+ * each other while the rule being illustrated happened somewhere inside. None of that
+ * apparatus is needed to show two charges meeting. Rays already move; that is what
+ * streaming is. The two rules already say what happens when they meet.
+ *
+ * Measured, on 208 charges:
+ *
+ * + − 208 → 0 104 annihilations, 0 deflections
+ * + + 208 → 152 0 annihilations, 170 deflections
+ * − − 208 → 152 0 annihilations, 170 deflections
+ *
+ * Opposite charges destroy each other completely. Alike charges all turn and come
+ * back, and the count only falls because the ones that turn around run off the far
+ * edge of the box. `+ +` and `− −` are identical, which they have to be.
+ */
+const CLUMP = { near: 9, far: 14, span: 8 };
+
+export const charges = (left: 1 | -1, right: 1 | -1): Seed => (w) => {
+ const g = w.geometry, b = w.backend;
+ const C = ((w.opts.N ?? 1) - 1) / 2;
+ const mid = g.embed(new Array(g.D).fill(C));
+ /*
+ * THE AXIS THEY MEET ON, taken from the geometry rather than assumed. Every lattice
+ * in this book has a ±x exit; which INDEX it is differs, and on triangular 6 it is
+ * not the one a square lattice would have made it.
+ */
+ const toward = g.V.findIndex(v => v[0] === 1 && !v.slice(1).some(x => x !== 0));
+ if (toward < 0) throw new Error(`${g.name} has no exit straight along x to collide on`);
+ const back = g.OPP[toward];
+
+ b.forEachLocal(k => {
+ const p = g.embed(b.position(k)).map((x, i) => x - (mid[i] ?? 0));
+ for (let i = 1; i < g.D; i++) if (Math.abs(p[i] ?? 0) > CLUMP.span) return;
+ const x = p[0] ?? 0;
+ if (x >= -CLUMP.far && x <= -CLUMP.near) b.put(k, toward, left);
+ else if (x >= CLUMP.near && x <= CLUMP.far) b.put(k, back, right);
+ });
+};
+
+/**
+ * THE PLANE THESE FIGURES RUN ON — faces only, and heavy matter in it.
+ *
+ * SIX EXITS, ALL OF THEM ONE CELL LONG. `square-8`'s diagonals are √2, so rays down
+ * them outrun the ones going straight for no reason a reader can see, and a picture
+ * of a rule ends up also being a picture of the lattice's grain. Taking the diagonals
+ * out fixes the lengths but leaves four exits, which is as anisotropic as a plane
+ * gets — rank four 0.667.
+ *
+ * Triangular 6 has both: ONE STEP LENGTH, c̄ one cell a tick down every exit, which is
+ * the setup the three rules are stated for — and EXACT at ranks two, three and four,
+ * which no square arrangement in the plane is.
+ *
+ * It had to be repaired first. Its ±√3/2 components do not land on the integer grid,
+ * the backend rounded them, and two thirds of its links came out one-way — measured
+ * HERE, as blocks that passed straight through each other with alike and opposite
+ * pairs behaving identically. In axial coordinates it is an integer lattice and the
+ * figure separates: alike close from 20 cells to 10, touch, and go out to 30;
+ * opposite close to 10 and stay.
+ */
+export const PLANE = {
+ theory: GRAVITY_MAGNETISM,
+ geometry: GEOMETRIES["triangular-6"],
+ N: 61, boundary: "absorb" as const, ...EMPTY,
+};
+
+/** two emitters across a gap, each pulsing its own polarity into the space between */
+export const emitters = (left: 1 | -1, right: 1 | -1): Seed => (w) => {
+ const C = ((w.opts.N ?? 1) - 1) / 2, gap = Math.max(2, Math.floor(C * 0.6));
+ w.add({ at: [C - gap, C], radius: 1, emits: left, duty: 1, absorbs: true });
+ w.add({ at: [C + gap, C], radius: 1, emits: right, duty: 1, absorbs: true });
+};
+
+/**
+ * THE ARRANGEMENTS, AS A GALLERY — every one of them the same rules, differing only in
+ * what was put in the world and how it was watched.
+ *
+ * This replaces a catalogue of runs from the archive's own simulator. The point of
+ * that catalogue was breadth: that one rule set, unchanged, produces all of these. It
+ * only makes that point if they are all the SAME rule set, which is exactly what could
+ * not be checked when the figures ran a different engine from the tests.
+ */
+export const Arrangements = ({ height = 240 }: { height?: number } = {}) => {
+ const plane = PLANE;
+ const slides: Slide[] = [
+ { key: "opposite", label: "two blocks, opposite polarity — they meet and annihilate",
+ render: () => {s.note}
: null}
+
+ {
+ let w: World;
+ let acc = 0;
+ return {
+ start: () => {
+ w = new World(s.world);
+ s.seed?.(w);
+ for (let i = 0; i < (s.warm ?? 0); i++) w.tick();
+ },
+ stop: () => { (w as unknown) = undefined; },
+ frame: (sur: Surface, dt: number) => {
+ if (playing) { acc += dt; while (acc > 1 / rate) { w.tick(); acc -= 1 / rate; } }
+ if (stepOnce.current > 0) { w.tick(); stepOnce.current--; }
+ setTicks(w.stats.ticks);
+
+ const { ctx, width, height: H } = sur;
+ ctx.clearRect(0, 0, width, H);
+
+ /*
+ * THE CAMERA IS FITTED TO THE WORLD RATHER THAN SET, because a world that
+ * EXPANDS does not stay the size it started. A fixed scale is right for a
+ * fixed grid and wrong for the one thing these pictures are here to show.
+ */
+ const C = ((w.opts.N ?? 1) - 1) / 2;
+ /*
+ * AND THE MIDDLE EMBEDDED WITH THEM. The box's centre is the INDEX (C, C);
+ * on a sheared lattice that is not the point (C, C) in space. Taking the
+ * raw C off an embedded position centres the picture on somewhere that is
+ * not the middle of anything, and the fitted radius then measures from
+ * there — which pushed the world off to one side and shrank it.
+ */
+ const mid = w.geometry.embed(new Array(w.geometry.D).fill(C));
+ const centred: Vec[] = []; const keys: number[] = [];
+ let R = 1;
+ w.backend.forEachLocal(k => {
+ /*
+ * DRAWN IN SPACE, NOT IN THE INDEX. A lattice's array coordinates are
+ * not its coordinates: triangular 6 is stored in axial (q, r) and its
+ * cells sit at q·a₁ + r·a₂, so plotting the indices straight onto a
+ * square grid shears the whole picture by 30° — blocks came out as
+ * parallelograms. `embed` is what the geometry says those indices mean.
+ */
+ const p = w.geometry.embed(w.backend.position(k))
+ .map((x, i) => x - (mid[i] ?? 0)) as Vec;
+ centred.push(p); keys.push(k);
+ R = Math.max(R, Math.hypot(p[0] ?? 0, p[1] ?? 0, p[2] ?? 0));
+ });
+ const view = s.view ?? R;
+ /*
+ * FACE ON IN TWO DIMENSIONS. The orbit camera is what makes a 3D block
+ * readable, and it is exactly wrong for a plane: yaw and pitch turn a
+ * flat lattice into a tilted parallelogram, which is a picture of the
+ * camera rather than of the model. A plane is drawn as a plane.
+ */
+ const flat = w.geometry.D === 2;
+ const cam: Cam = {
+ yaw: flat ? 0 : 0.6, pitch: flat ? 0 : 0.42,
+ scale: Math.min(width, H) / (2.4 * Math.max(view, 1)),
+ cx: width / 2, cy: H / 2,
+ };
+
+ /*
+ * NEUTRAL SPACE IS DRAWN FAINT AND SMALL, AND THAT IS THE WHOLE PICTURE.
+ *
+ * A first version drew every point the same way and produced a solid grey
+ * cube: in an 11³ box the charges are a handful of points among 1,331 and
+ * the outer shell hides all of them. `LATTICE.tsx` already knew this — it
+ * draws strips rather than blocks for exactly this reason — but a player
+ * has to show the whole box, so the separation has to be in the drawing.
+ *
+ * Two passes: space that is holding nothing, barely there; and what is
+ * actually happening, at full weight over it.
+ */
+ const key = new Map(centred.map((p, i) => [p, keys[i]]));
+ const colour = colourOf(w, show);
+ const isPlain = (p: Vec) => {
+ const c = colour(key.get(p)!);
+ return !c || (c[0] === NEUTRAL[0] && c[1] === NEUTRAL[1] && c[2] === NEUTRAL[2]);
+ };
+ connections(ctx, w.geometry, centred, cam, 0.07);
+ nodes(ctx, centred, cam, p => (isPlain(p) ? NEUTRAL : undefined), 0.9, 0.30);
+ nodes(ctx, centred, cam, p => (isPlain(p) ? undefined : colour(key.get(p)!)), 2.6);
+ },
+ };
+ }} />
+
+
+ setPlaying(p => !p)} />
+ { stepOnce.current++; }} />
+ setEpoch(e => e + 1)} />
+ {ticks} ticks
+
+
+
;
diff --git a/orbitmines.com/src/routes/Physics/visuals/RENDER.tsx b/orbitmines.com/src/routes/Physics/visuals/RENDER.tsx
new file mode 100644
index 00000000..73991af5
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/RENDER.tsx
@@ -0,0 +1,721 @@
+/**
+ * THE PANELS — drawn from the same core the measurements use, so a picture and a
+ * number can no longer disagree.
+ *
+ * Every panel below constructs a `World` from DISCRETE.ts with an explicit theory
+ * and geometry, ticks it, and reads the SAME observables the tests read. There is no
+ * second implementation of the rules for drawing purposes, which is what the old
+ * `grid.tsx` and `current.tsx` were and is how they came to be showing a vacuum a
+ * fifth of the derived density.
+ *
+ * WHAT RENDERING KEEPS CATCHING, recorded so it is not re-learned:
+ *
+ * A DIFFERENCE, NOT A TOTAL. A source emits along its EXITS, so what dominates a
+ * raw frame is pencil beams that are identical in every configuration. Two panels
+ * meant to show opposite physics came out looking the same. Each panel here runs a
+ * CONTROL world at the same seed and draws the difference.
+ *
+ * AND THE DIFFERENCE HAS A DC OFFSET. A second body changes the vacuum's own
+ * statistics everywhere, which rendered as a uniform wash with the signal buried
+ * in it. The far field is where nothing local happens, so its mean is that offset.
+ *
+ * A SHARED SCALE, NOT A PER-PANEL PEAK. Normalising each panel to its own maximum
+ * makes them incomparable and reads backwards — a panel where almost nothing
+ * happens turns its own shot noise up to full brightness beside a panel with a
+ * real signal.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import {
+ World, Theory, Geometry, GRAVITY, GRAVITY_MAGNETISM, LABELLED, GEOMETRIES,
+ l, fieldB, fill, withSign,
+} from "../DISCRETE";
+
+const BACK = "#08090d", FAINT = "#5a5f6e", SEEN = "#eef0f5";
+const PLUS = "#4aa8eb", MINUS = "#eb964a", DESTROYED = "#e0685f", TRAFFIC = "#6fd39b";
+
+/** what a panel reads off a local, and how it is coloured */
+export type Channel = {
+ name: string;
+ /** the value at a local, already differenced against the control by the caller */
+ at: (w: World, local: number) => number;
+ /** signed: two colours; unsigned: one */
+ positive: string;
+ negative?: string;
+ /**
+ * Whether this reading has to be ACCUMULATED over ticks or is already a total.
+ *
+ * A single tick of this vacuum is noise. Reading how many rays are present at a
+ * local right now and differencing it against another world gives a difference of
+ * two random numbers — rendered, it is a uniform speckle with the physics
+ * invisible inside it, which is exactly what the first version of these panels
+ * drew. `density` is already cumulative because a fold is permanent; everything
+ * else has to be summed over time, and the sum IS the measurement.
+ */
+ cumulative?: boolean;
+};
+
+export const CHANNELS = {
+ /**
+ * WHERE SPACE HAS BEEN DESTROYED — the metric channel, and the article's pull.
+ *
+ * READ OUT OF `w.destroyed`, NOT `backend.density`. Density counts how much space
+ * has been FOLDED into a point, and on-edge annihilation does not fold: it collapses
+ * the point the split inserted BETWEEN two others and leaves both ends alone. So
+ * density stopped moving when the meeting rule was settled, and this channel — the
+ * one every "pull" panel in the article is drawn from — silently went flat. The
+ * panels kept rendering; the layer they were about was blank.
+ *
+ * `w.destroyed` is the per-point annihilation count, credited half to each end of
+ * the edge the event happened on, and it is the same quantity the force
+ * measurements read. `before` is still taken so the signature does not change and
+ * so a panel can be drawn against a warmed world.
+ */
+ destroyed: (before: Int32Array): Channel => ({
+ name: "space destroyed — the pull",
+ at: (w, k) => (k < w.destroyed.length ? w.destroyed[k] : 0) - (before[k] ?? 0),
+ positive: DESTROYED,
+ cumulative: true, // a count only ever grows, so it already sums
+ }),
+ /** how much is present — the mechanical channel, and the push */
+ traffic: (): Channel => ({
+ name: "rays that survived — the push",
+ at: (w, k) => l.rays(w, k).length,
+ positive: TRAFFIC, negative: MINUS,
+ }),
+ /** the net polarity, which IS the electric field */
+ charge: (): Channel => ({
+ name: "net polarity — the electric field",
+ at: (w, k) => l.charge(w, k),
+ positive: PLUS, negative: MINUS,
+ }),
+ /** B = Σσ(d̂ × u), out of the plane */
+ magnetic: (axis = 2): Channel => ({
+ name: "B = Σσ(d̂ × u), read off the rays",
+ at: (w, k) => fieldB(w, k)[axis] ?? 0,
+ positive: PLUS, negative: MINUS,
+ }),
+} as const;
+
+export type PanelSpec = {
+ note: string;
+ /** draw a dot for each source; off where the claim is that the field hides them */
+ markers?: boolean;
+ theory: Theory;
+ geometry?: Geometry;
+ /** the world under test, and the control it is drawn against */
+ build: (w: World) => void;
+ control?: (w: World) => void;
+ /**
+ * DRAW THE FIELD ITSELF, NOT A DIFFERENCE — for the one kind of panel where a
+ * control is a contradiction.
+ *
+ * Every other panel here asks what a body DOES to the vacuum, and the honest way
+ * to ask that is to run the vacuum again without the body and subtract. But a
+ * panel whose subject IS the vacuum has no body to leave out, so its control is
+ * the same world at the same seed: the difference is identically zero at every
+ * point, the far-field spread the colour scale is taken from is zero, and the
+ * panel renders permanently black. It did. Nothing was wrong with the physics —
+ * the picture was of a quantity that had been subtracted from itself.
+ */
+ absolute?: boolean;
+ channels: (before: Int32Array) => Channel[];
+ N?: number;
+ expansion?: number;
+ /** how much of the box to ink; the rest is run but not drawn */
+ view?: number;
+ warm?: number;
+ height?: number;
+};
+
+/**
+ * THE PANELS RUN IN TWO DIMENSIONS, and that is a decision rather than a shortcut.
+ *
+ * A panel is a picture of one plane. Running a 41³ world to draw a slice of it costs
+ * sixty-eight thousand locals a tick against a plane's fourteen thousand at 121² —
+ * for pixels nobody sees. Measured, the 3D version did not finish. `triangular-6` is
+ * the same three rules with DEG = 6, and every constant a panel needs comes out of it
+ * the same way, so it is a row of `geometry/derived-constants` rather than a special
+ * case.
+ *
+ * TRIANGULAR RATHER THAN SQUARE, for the reason the default is FCC rather than cubic
+ * 26. `square-8`'s eight exits are two different lengths, 1 and √2, so rays down the
+ * diagonals outrun the ones going straight and a picture of a rule is also a picture
+ * of the lattice's grain; taking the diagonals out fixes that and leaves four exits,
+ * which is as anisotropic as a plane gets. Triangular 6 has ONE STEP LENGTH — exactly
+ * 1, so c̄ is one cell a tick down every exit — equal weights, and it is EXACT at
+ * ranks two, three and four, which no square arrangement in the plane is. It stands
+ * to the panels as fcc-12 stands to the measurements.
+ *
+ * It could not be run until the lattice was fixed. Its exits carry ±√3/2, the backend
+ * stepped through the array by ROUNDING them, and rounding is not antipodal — two
+ * thirds of its links were one-way, so every head-on meeting looked for its partner
+ * in the wrong cell. In axial coordinates it is plainly an integer lattice; see
+ * `GeometrySpec.L`.
+ *
+ * What is still lost is named: SHEET is 2 rather than 8, and rank six is 0.200. A
+ * panel shows the MECHANISM; the numbers belong to the measurements, which run in
+ * three.
+ */
+const make = (s: PanelSpec, build: (w: World) => void) => {
+ const w = new World({
+ theory: s.theory, geometry: s.geometry ?? GEOMETRIES["triangular-6"], N: s.N ?? 121,
+ /*
+ * p = 1, WHICH IS THE RULE. (G/2) says a neutral point expands ON ALL AXIS — it
+ * is not gated on anything, and `World`'s own default is 1. These panels ran at
+ * 0.05 because that is what the archive's automaton used, and the archive's
+ * automaton had a rate because it was written before the rule was settled.
+ *
+ * It is not a small correction. At p = 1 gravity+magnetism settles at fill
+ * 0.5019 — the derived fixed point ½, on the nose, on both lattices — against
+ * 0.2449 at p = 0.06. Half the vacuum was missing from every one of these
+ * pictures.
+ */
+ seed: 20260817, boundary: "absorb",
+ });
+ build(w);
+ return w;
+};
+
+/** the far-field mean, which is the offset a second body adds everywhere */
+/*
+ * WHERE A LOCAL ACTUALLY IS. A lattice's array coordinates are not its coordinates —
+ * triangular 6 is stored in axial (q, r) and sits at q·a₁ + r·a₂ — so every distance
+ * and every pixel here goes through the geometry's own embedding. It is the identity
+ * on every cubic lattice, so nothing else moves.
+ */
+const where = (w: World, k: number) => w.geometry.embed(w.backend.position(k));
+
+/*
+ * AND THE MIDDLE HAS TO BE EMBEDDED TOO. The box's centre is the index (C, C, …); on
+ * a sheared lattice that is NOT the point (C, C, …) in space. Subtracting the raw C
+ * from an embedded position measures from somewhere that is not the middle of
+ * anything, which puts the far-field annulus off centre and slides the whole drawing
+ * out of frame.
+ */
+const middle = (w: World, C: number) =>
+ w.geometry.embed(new Array(w.geometry.D).fill(C));
+
+const offset = (w: World, f: (k: number) => number, C: number, view: number) => {
+ let s = 0, n = 0;
+ w.backend.forEachLocal(k => {
+ if (w.isSource(k)) return;
+ const p = where(w, k), m = middle(w, C);
+ const d = Math.hypot(...p.map((x, i) => x - m[i]));
+ if (d < view + 8) return;
+ s += f(k); n++;
+ });
+ return n ? s / n : 0;
+};
+
+export const Panel = (s: PanelSpec) => {
+ const height = s.height ?? 300;
+ return
+ the same mechanism with the static taken out — the deterministic limit of (G/1)
+ and (G/2), where the deficit is exact, propagates at c̄, and needs no averaging
+
+
+ {
+ let w = born();
+ let acc = 0;
+ return {
+ start: () => {
+ w = born();
+ // headless draws ONE frame, so it has to arrive already ticked
+ const want = startAt || (typeof IntersectionObserver === "undefined" ? 120 : 0);
+ for (let i = 0; i < want; i++) step(w);
+ },
+ frame: (s: Surface, dt: number) => {
+ acc += dt;
+ // one tick is one cell of travel, so the front is visible at this rate
+ while (acc > 1 / 26) { acc -= 1 / 26; if (w.t >= 260) w = born(); else step(w); }
+
+ const { ctx, width, height: H } = s;
+ ctx.clearRect(0, 0, width, H);
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, H);
+
+ const TOP = 20, BOT = 18, GAP2 = 10;
+ const cw = (width - GAP2) / 2;
+ const side = Math.min(cw, H - TOP - BOT);
+ const pz = side / (2 * VIEW + 1);
+ const top = TOP + Math.max(0, (H - TOP - BOT - side) / 2);
+
+ // the level far from either body — the zero the deficit is drawn against
+ let bg = 0, bn = 0;
+ for (let y = -VIEW; y <= VIEW; y += 2) for (let x = -VIEW; x <= VIEW; x += 2)
+ if (Math.hypot(x + GAP / 2, y) > 40 && Math.hypot(x - GAP / 2, y) > 40) {
+ bg += w.q[at(C + x, C + y)]; bn++;
+ }
+ bg = bn ? bg / bn : DEG;
+
+ /*
+ * LOGARITHMIC. `d` is the shortfall as a fraction of the far field, and
+ * what is inked is log(1 + d/floor) / log(1 + 1/floor) — so the deepest
+ * shortfall is full ink, a tenth of it is still better than half ink, and
+ * a thousandth is still visible. Linear, everything past r = 8 is under
+ * the first shade and the panel is a dot.
+ */
+ const FLOOR = 0.002;
+ const lg = (d: number) =>
+ Math.log(1 + Math.max(0, d) / FLOOR) / Math.log(1 + 1 / FLOOR);
+
+ for (const col of [0, 1]) {
+ const cx = (col === 0 ? cw / 2 : cw + GAP2 + cw / 2), cy = top + side / 2;
+ for (let y = -VIEW; y <= VIEW; y++) for (let x = -VIEW; x <= VIEW; x++) {
+ const c = at(C + x, C + y);
+ if (w.body[c]) continue;
+ const v = col === 0
+ ? Math.min(1, w.q[c] / Math.max(bg, 1e-9)) // what is there
+ : lg((bg - w.q[c]) / Math.max(bg, 1e-9)); // what is MISSING
+ if (v <= 0.004) continue;
+ ctx.globalAlpha = Math.min(1, v);
+ ctx.fillStyle = col === 0 ? RAIN : MISS;
+ ctx.fillRect(cx + x * pz - pz / 2, cy + y * pz - pz / 2, pz + 0.6, pz + 0.6);
+ }
+ ctx.globalAlpha = 1;
+
+ [-GAP / 2, GAP / 2].forEach((dx, k) => {
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 1.2;
+ ctx.beginPath();
+ ctx.arc(cx + dx * pz, cy, (R + 0.8) * pz, 0, 2 * Math.PI);
+ ctx.stroke();
+
+ if (col !== 1 || !w.t) return;
+ /*
+ * NO COMMON-MODE TO REMOVE, because there is no noise: the two bodies
+ * are exactly symmetric and the rule is deterministic, so the pushes
+ * come out exactly equal and opposite rather than approximately.
+ */
+ /*
+ * SCALED BY THE LARGER OF THE TWO, and clamped. Scaling by their
+ * DIFFERENCE — which is what the archive did — divides by nearly zero
+ * exactly when the two are closest to equal and opposite, which is
+ * when the panel is most nearly right: at t = 8 both read 4, the
+ * difference is 0, and the arrows shot off the canvas.
+ */
+ const big = Math.max(1, ...w.F.map(f => Math.hypot(f[0], f[1])));
+ const sc = Math.min(26, 26 / big * Math.hypot(w.F[k][0], w.F[k][1])) /
+ Math.max(1e-9, Math.hypot(w.F[k][0], w.F[k][1]));
+ const fx = w.F[k][0] * sc, fy = w.F[k][1] * sc;
+ if (Math.hypot(fx, fy) < 2) return;
+ const x0 = cx + dx * pz, y0 = cy;
+ ctx.strokeStyle = GOOD; ctx.lineWidth = 1.8;
+ ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x0 + fx, y0 + fy); ctx.stroke();
+ const a = Math.atan2(fy, fx);
+ ctx.beginPath();
+ ctx.moveTo(x0 + fx, y0 + fy);
+ ctx.lineTo(x0 + fx - 6 * Math.cos(a - 0.4), y0 + fy - 6 * Math.sin(a - 0.4));
+ ctx.moveTo(x0 + fx, y0 + fy);
+ ctx.lineTo(x0 + fx - 6 * Math.cos(a + 0.4), y0 + fy - 6 * Math.sin(a + 0.4));
+ ctx.stroke();
+ });
+ }
+
+ ctx.font = "11px ui-monospace, monospace";
+ ctx.textAlign = "center";
+ ctx.fillStyle = INK;
+ ctx.fillText("the charges themselves", cw / 2, 13);
+ ctx.fillText("how many are MISSING — log scale", cw + GAP2 + cw / 2, 13);
+
+ ctx.font = "10px ui-monospace, monospace";
+ ctx.fillStyle = FAINT;
+ // the total, not the per-tick rate: it is a running sum and the per-tick
+ // figure rounds to three zeros while the arrow is plainly there
+ const p = w.F.map(f => String(f[0]));
+ ctx.fillText(`t = ${w.t} · push on each body ${p[0]} and ${p[1]}` +
+ ` — whole rays, no averaging`, width / 2, H - 5);
+ ctx.textAlign = "left";
+ },
+ };
+ }} />
+
+
+
;
+};
+
+const paint = (
+ sur: Surface, w: World, chans: Channel[], read: ((k: number) => number)[],
+ C: number, view: number, ticks: number, markers = true, ready = 1,) => {
+ const { ctx, width, height } = sur;
+ const mid = middle(w, C);
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+ const cols = chans.length;
+ const cw = width / cols, H = height - 26;
+ const VN = 2 * view + 1;
+ const s = Math.min(cw / VN, H / VN);
+ const oy = 20 + (H - 20 - VN * s) / 2;
+
+ chans.forEach((ch, ci) => {
+ const ox = ci * cw + (cw - VN * s) / 2;
+ const dc = read[ci];
+ const off = offset(w, dc, C, view);
+ /*
+ * THE SCALE IS THE SPREAD OF THE DIFFERENCE ITSELF, taken in the far field where
+ * nothing local is happening — so the colour means "this many times the level
+ * this quantity fluctuates at anyway". Normalising to a panel's own PEAK makes
+ * panels incomparable and reads backwards: one where almost nothing happens
+ * turns its own shot noise up to full brightness beside one with a real signal.
+ */
+ let v2 = 0, n = 0;
+ w.backend.forEachLocal(k => {
+ if (w.isSource(k)) return;
+ const p = where(w, k);
+ if (Math.hypot(...p.map((x, i) => x - mid[i])) < view + 8) return;
+ const d = dc(k) - off; v2 += d * d; n++;
+ });
+ const scale = n ? Math.max(Math.sqrt(v2 / n), 1e-12) : 1;
+
+ w.backend.forEachLocal(k => {
+ const p = where(w, k);
+ if (p.length > 2 && Math.abs(p[2] - mid[2]) > 0.5) return; // one plane, in 3D
+ const x = p[0] - mid[0] + view, y = p[1] - mid[1] + view;
+ if (x < 0 || y < 0 || x >= VN || y >= VN) return;
+ if (w.isSource(k)) return;
+ // in units of the far-field spread: two of those is a signal, and below one is
+ // indistinguishable from the vacuum doing what it does anyway
+ const v = (dc(k) - off) / scale;
+ if (Math.abs(v) < 1) return;
+ ctx.globalAlpha = Math.min(0.92, (Math.abs(v) - 1) * 0.35);
+ ctx.fillStyle = v > 0 ? ch.positive : (ch.negative ?? ch.positive);
+ ctx.fillRect(ox + x * s, oy + y * s, Math.max(s, 1), Math.max(s, 1));
+ });
+ ctx.globalAlpha = 1;
+
+ /*
+ * THE MARKERS ARE OPTIONAL, because on some panels drawing them contradicts the
+ * claim. The three sign-convention panels exist to show that a single tick of the
+ * vacuum does NOT show the structure in it — and a ring of source dots painted
+ * over the field shows it whatever the field is doing, which makes the picture
+ * argue the opposite of its caption. Where the point is "you cannot see it here",
+ * only what was measured is drawn.
+ */
+ for (const src of (markers ? w.sources : [])) {
+ const p = where(w, src.locals[0]);
+ if (p.length > 2 && Math.abs(p[2] - mid[2]) > 2) continue;
+ let cx = 0, cy = 0, m = 0;
+ for (const k of src.locals) {
+ const q = where(w, k);
+ if (q.length > 2 && Math.abs(q[2] - mid[2]) > 0.5) continue;
+ cx += q[0]; cy += q[1]; m++;
+ }
+ if (!m) continue;
+ ctx.beginPath();
+ ctx.arc(ox + (cx / m - mid[0] + view) * s, oy + (cy / m - mid[1] + view) * s, 2.2 * s, 0, 7);
+ ctx.fillStyle = src.emits > 0 ? PLUS : src.emits < 0 ? MINUS : "#2a2e38";
+ ctx.fill();
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 1.2; ctx.stroke();
+ }
+
+ ctx.font = "10px ui-monospace, monospace";
+ ctx.fillStyle = FAINT; ctx.textAlign = "center";
+ ctx.fillText(ch.name, ci * cw + cw / 2, 14);
+ });
+
+ /*
+ * THE CAPTION IS ALREADY ABOVE THE CANVAS, so drawing it again inside it bought
+ * nothing and cost the readout: the two ran into each other in the same line of
+ * pixels and the tick count came out written through the end of the sentence.
+ * Only what cannot be in the caption — what this particular run did — is drawn.
+ */
+ ctx.textAlign = "right";
+ ctx.fillStyle = FAINT;
+ ctx.fillText(`${ticks} ticks · fill ${fill(w).toFixed(2)}`, width - 10, height - 10);
+ ctx.textAlign = "left";
+
+ // how much of the average is in yet — a panel that is still filling in says so
+ if (ready < 1) {
+ ctx.fillStyle = "#1a1d25"; ctx.fillRect(0, height - 2, width, 2);
+ ctx.fillStyle = FAINT; ctx.fillRect(0, height - 2, width * ready, 2);
+ }
+};
+
+// ─── the panels the article uses ────────────────────────────────────────────
+
+/** a position with as many components as the geometry has dimensions */
+const at = (w: World, ...c: number[]) => c.slice(0, w.geometry.D);
+
+const pair = (a: 1 | -1 | 0, b: 1 | -1 | 0, sep = 14) => (w: World) => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C - sep / 2, C, C), radius: 3, emits: a, absorbs: true, duty: a === 0 ? 0 : 1 });
+ w.add({ at: at(w, C + sep / 2, C, C), radius: 3, emits: b, absorbs: true, duty: b === 0 ? 0 : 1 });
+};
+const lone = (a: 1 | -1 | 0, sep = 14) => (w: World) => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C - sep / 2, C, C), radius: 3, emits: a, absorbs: true, duty: a === 0 ? 0 : 1 });
+};
+
+/** two alike charges: nothing annihilates between them, so the rays land — the push */
+export const Alike = ({ height = 300 }: { height?: number }) => Panel({
+ height, note: "two alike charges — nothing annihilates between them, so the partner's rays " +
+ "survive the crossing and land: THE PUSH",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 26,
+ build: pair(1, 1), control: lone(1),
+ channels: before => [CHANNELS.traffic(), CHANNELS.destroyed(before)],
+});
+
+/** two opposite charges: the gap is destroyed rather than crossed — the pull */
+export const Opposite = ({ height = 300 }: { height?: number }) => Panel({
+ height, note: "two opposite charges — the same two rules, the other branch: the gap is " +
+ "destroyed rather than crossed",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 26,
+ build: pair(1, -1), control: lone(1),
+ channels: before => [CHANNELS.traffic(), CHANNELS.destroyed(before)],
+});
+
+/** gravity: two inert absorbers, and the vacuum's own shadow between them */
+export const Gravity = ({ height = 300 }: { height?: number }) => Panel({
+ height, note: "two INERT absorbers in the gravity theory — they eat the vacuum and emit " +
+ "nothing, so what draws them together is the vacuum's own pressure with a shadow in it",
+ theory: GRAVITY, N: 121, view: 26,
+ build: pair(0, 0), control: lone(0),
+ channels: before => [CHANNELS.traffic(), CHANNELS.destroyed(before)],
+});
+
+/** the magnetic field of a moving charge, beside the same charge at rest */
+export const MovingCharge = ({ height = 320 }: { height?: number }) => Panel({
+ height, note: "a moving charge — B is transverse to the motion and reverses across it, and " +
+ "is EXACTLY nothing at rest, because a ray from a stationary charge carries the label 0",
+ theory: LABELLED, N: 121, view: 26,
+ build: w => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C, C, C), radius: 3, emits: 1, u: at(w, 0, 0.5, 0) });
+ },
+ control: w => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C, C, C), radius: 3, emits: 1 }); // the same charge, standing still
+ },
+ channels: () => [CHANNELS.magnetic(2), CHANNELS.charge()],
+});
+
+/**
+ * TWO WIRES. Each is a line of sources whose POLARITY carries the current — the
+ * cells on one side of the line emit +1 and on the other −1, so there is no net
+ * charge and the direction of the current is in the sign.
+ *
+ * IT HAS TO BE BUILT THAT WAY FOR A FORCE TO EXIST AT ALL, and the two constructions
+ * of a wire in this book are not interchangeable. A wire made of counter-drifting
+ * LABELLED carriers gives the right field — Ampère's 1/r, no curl taken — and has
+ * no magnetic force whatever, because its polarity distribution is identical
+ * whichever way the current runs and a label does not enter the collision rules.
+ * A wire whose polarity carries the current has the force and the wrong field
+ * exponent. Joining them needs carriers that actually move, which is owed.
+ *
+ * So these panels show the FORCE, and `MovingCharge` shows the FIELD.
+ */
+const wire = (sense: 1 | -1, x: number) => (w: World) => {
+ const N = w.opts.N;
+ for (let y = 4; y < N - 4; y++)
+ w.add({ at: at(w, x, y, (N - 1) / 2), radius: 0.9, emits: (y % 2 === 0 ? sense : -sense) as 1 | -1 });
+};
+const wires = (a: 1 | -1, b: 1 | -1 | 0, sep = 14) => (w: World) => {
+ const C = (w.opts.N - 1) / 2;
+ wire(a, C - sep / 2)(w);
+ if (b !== 0) wire(b, C + sep / 2)(w);
+};
+
+/** parallel currents: the rays that face each other carry opposite signs, so they annihilate */
+export const WiresParallel = ({ height = 300 }: { height?: number }) => Panel({
+ height, note: "two parallel currents — the rays that face each other carry OPPOSITE signs, " +
+ "so they annihilate and the space between the wires is destroyed: ATTRACT",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 26,
+ build: wires(1, 1), control: wires(1, 0),
+ channels: before => [CHANNELS.traffic(), CHANNELS.destroyed(before)],
+});
+
+/** antiparallel: the facing rays are alike, so they turn and survive */
+export const WiresAnti = ({ height = 300 }: { height?: number }) => Panel({
+ height, note: "two antiparallel currents — the facing rays carry the SAME sign, so they turn " +
+ "and survive the crossing: REPEL",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 26,
+ build: wires(1, -1), control: wires(1, 0),
+ channels: before => [CHANNELS.traffic(), CHANNELS.destroyed(before)],
+});
+
+// ─── the gravity arc's own panels, on the core ──────────────────────────────
+
+/**
+ * WHAT THE VACUUM DOES ON ITS OWN — which is the whole of the gravity mechanism
+ * before any matter is put in it.
+ *
+ * (G+M/2) makes new room and the same expansion thins what is already there, and
+ * the two together have a fixed point nobody chose. A panel of it is not a picture
+ * of anything happening to a body: it is the pressure a body will later be in.
+ */
+export const VacuumAlone = ({ height = 260 }: { height?: number }) => Panel({
+ height, note: "the vacuum with nothing in it, drawn as itself rather than as a difference — " +
+ "it is HOMOGENEOUS, so what there is to see is the grain: no place is special, and every " +
+ "place is busy. This is the pressure everything else is measured against",
+ /*
+ * FORTY TICKS, NOT THREE HUNDRED — and the difference is a second and a half of
+ * the page's first paint, because this panel is the book's header.
+ *
+ * Warm-up buys two different things and this panel only needs one of them. It has
+ * to REACH the vacuum's fixed point, and it does: fill is 0.049 after one tick,
+ * 0.208 by ten and 0.221 by twenty, and it does not move again. The other thing —
+ * averaging a signal out of the noise — is what the panels with a body in them
+ * need, and it does nothing here, because the colour scale is normalised to the
+ * field's own far-field spread and this field is HOMOGENEOUS. Averaging shrinks
+ * the signal and the scale together, so the picture at forty samples and at three
+ * hundred are the same picture. The extra 260 ticks were 1.5s of a blank header.
+ */
+ theory: GRAVITY_MAGNETISM, N: 121, view: 26, warm: 40,
+ absolute: true,
+ build: () => {},
+ channels: before => [CHANNELS.traffic(), CHANNELS.destroyed(before)],
+});
+
+/**
+ * THE DEFICIT — matter in the way of the expansion.
+ *
+ * A body eats the rays that arrive at it, so the vacuum around it is short of what
+ * it would otherwise have, and that shortfall spreads at c̄. It is the mechanism
+ * rather than the observable — the force is what a SECOND body does to it — but it
+ * is the thing the article's gravity arc is about, and it can be looked at.
+ */
+export const Deficit = ({ height = 260 }: { height?: number }) => Panel({
+ height, note: "one inert absorber in the gravity theory — the shortfall it leaves in the " +
+ "vacuum's own traffic, which is what spreads at c̄ and what a second body then feels",
+ theory: GRAVITY, N: 121, view: 30, warm: 260,
+ build: w => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C, C, C), radius: 3, absorbs: true, duty: 0 });
+ },
+ control: () => {},
+ channels: () => [CHANNELS.traffic()],
+});
+
+/**
+ * THE VEINS, AND WHETHER THE VACUUM TAKES THEM OUT — the two limits side by side.
+ *
+ * Left: a source in an EMPTY box, which is the collisionless limit the geometry
+ * table computes in, and where a body diagonal really does run √3 times as far in a
+ * tick. Right: the same source in the model's own vacuum, where a ray meets
+ * something every few cells and a ray that has been turned is on a different exit
+ * from the one it left on.
+ *
+ * The measurement is `geometry/veins`; this is what it is a measurement OF.
+ */
+export const Veins = ({ height = 300 }: { height?: number }) => {s.note}
+
+ {
+ let w: World, ctl: World;
+ let chans: Channel[] = [], ctlChans: Channel[] = [];
+ /** the running sum of each channel's difference, which is what gets drawn */
+ let sums: Float64Array[] = [];
+ let samples = 0;
+ const N = s.N ?? 121, C = (N - 1) / 2, view = s.view ?? Math.min(30, C - 2);
+ let acc = 0;
+
+ /*
+ * THE BASELINE THE CUMULATIVE CHANNELS ARE DIFFERENCED AGAINST. Taken from
+ * `destroyed` for the same reason the channel reads it: density does not move
+ * under on-edge annihilation, so a baseline taken from density is a baseline
+ * of zeroes against a quantity that is also zero.
+ */
+ const snapshot = (x: World) => {
+ const a = new Int32Array(x.backend.size());
+ x.backend.forEachLocal(k => { a[k] = k < x.destroyed.length ? x.destroyed[k] : 0; });
+ return a;
+ };
+
+ /*
+ * ONE TICK OF BOTH WORLDS, AND THE DIFFERENCE ADDED IN.
+ *
+ * Accumulating the DIFFERENCE rather than differencing the accumulations is
+ * the same number, and it is what lets a cumulative channel and a per-tick
+ * one be drawn side by side without either needing to know about the other.
+ */
+ const step = () => {
+ w.tick(); if (ctl) ctl.tick();
+ samples++;
+ for (let ci = 0; ci < chans.length; ci++) {
+ const a = chans[ci], b = ctlChans[ci], out = sums[ci];
+ if (a.cumulative) continue; // already a total; read at the end
+ if (ctl) w.backend.forEachLocal(k => { out[k] += a.at(w, k) - b.at(ctl, k); });
+ else w.backend.forEachLocal(k => { out[k] += a.at(w, k); });
+ }
+ };
+
+ /*
+ * THE AVERAGE IS THE MEASUREMENT, so it has to exist before the panel means
+ * anything — but building it inside `start()` froze the tab. `start` runs
+ * from an IntersectionObserver callback, on the main thread, and a few
+ * hundred ticks of a 121² world with its control is a second or two of a
+ * page that has stopped responding, once per panel as the reader scrolls
+ * past it. Nothing was slow; it was all being spent at once.
+ *
+ * So the warm-up is spread over frames on a time budget, and the panel
+ * paints from the first frame with however much average it has. It fills in
+ * while it is watched instead of arriving whole after a stall.
+ *
+ * HEADLESS IS THE EXCEPTION and takes it in one go: there is no second
+ * frame there — the renderer draws once and the picture has to be finished.
+ */
+ const WARM = s.warm ?? 200;
+ const HEADLESS = typeof IntersectionObserver === "undefined";
+ const BUDGET_MS = 12; // ~⅔ of a 60Hz frame
+ let warmed = 0;
+
+ return {
+ start: () => {
+ w = make(s, s.build);
+ ctl = s.absolute ? (undefined as unknown as World) : make(s, s.control ?? (() => {}));
+ chans = s.channels(snapshot(w));
+ ctlChans = ctl ? s.channels(snapshot(ctl)) : chans;
+ sums = chans.map(() => new Float64Array(w.backend.size()));
+ samples = 0; warmed = 0;
+ if (HEADLESS) { for (; warmed < WARM; warmed++) step(); }
+ },
+ stop: () => { (w as unknown) = undefined; (ctl as unknown) = undefined; sums = []; },
+ frame: (sur: Surface, dt: number) => {
+ if (warmed < WARM) {
+ const t0 = performance.now();
+ while (warmed < WARM && performance.now() - t0 < BUDGET_MS) { step(); warmed++; }
+ } else {
+ acc += dt;
+ while (acc > 1 / 20) { step(); acc -= 1 / 20; }
+ }
+ const read = chans.map((ch, ci) => ch.cumulative
+ ? (ctl ? (k: number) => ch.at(w, k) - ctlChans[ci].at(ctl, k)
+ : (k: number) => ch.at(w, k))
+ : (k: number) => sums[ci][k] / Math.max(samples, 1));
+ paint(sur, w, chans, read, C, view, w.stats.ticks, s.markers !== false,
+ warmed < WARM ? warmed / WARM : 1);
+ },
+ };
+ }} />
+
+
+ {Panel({
+ height, note: "a source in an EMPTY box — the collisionless limit, where the lattice's " +
+ "grain is the whole picture and a body diagonal covers √3 cells in a tick",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 34, warm: 60,
+ build: w => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C, C, C), radius: 2, emits: 1 });
+ },
+ control: () => {},
+ channels: () => [CHANNELS.charge()],
+ })}
+ {Panel({
+ height, note: "the same source in the model's own vacuum — a ray meets something every " +
+ "few cells, and a ray that has been turned is on a different exit from the one it left on",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 34, warm: 200,
+ build: w => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C, C, C), radius: 2, emits: 1 });
+ },
+ control: () => {},
+ channels: () => [CHANNELS.charge()],
+ })}
+
;
+
+/**
+ * THE SHEET — l.SHEET rays pulsed in a plane that comes round, which is how the
+ * article derives 1/R^(D−1): a FIXED number of rays spread over a shell.
+ *
+ * Both halves are the same source; only the emission differs. Isotropic fires every
+ * exit every tick, which is the approximation every measurement in this book has
+ * used; `sheet` fires the equator of an axis that steps round the ring, which is
+ * what the article actually describes.
+ */
+export const SheetEmission = ({ height = 300 }: { height?: number }) =>
+ {Panel({
+ height, note: "ISOTROPIC emission — every exit, every tick. The approximation the " +
+ "measurements use",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 30, warm: 200,
+ build: w => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C, C, C), radius: 2, emits: 1, emission: "isotropic" });
+ },
+ control: () => {},
+ channels: () => [CHANNELS.charge()],
+ })}
+ {Panel({
+ height, note: "SHEET emission — l.SHEET rays in a plane that comes round one ring step a " +
+ "tick, which is what the inverse-square law is derived from",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 30, warm: 200,
+ build: w => {
+ const C = (w.opts.N - 1) / 2;
+ w.add({ at: at(w, C, C, C), radius: 2, emits: 1, emission: "sheet" });
+ },
+ control: () => {},
+ channels: () => [CHANNELS.charge()],
+ })}
+
;
+
+/*
+ * THE VACUUM'S ONE FREE DRAW, AND WHAT AVERAGING DOES TO IT.
+ *
+ * These replace the archive's `ribbon.tsx` panels. The point they make is the same
+ * one: (G+M/2) fixes where and when a creation fires and leaves only the SIGN open,
+ * so the three conventions are the whole of the model's randomness — and none of the
+ * three shows a structure at a single tick, because a structure is one object in a
+ * field that fills every point. It is AVERAGING that makes it visible.
+ *
+ * WHAT CHANGED IS WHAT IS UNDERNEATH. `ribbon.tsx` ran its own automaton; these run
+ * `DISCRETE.ts` with `withSign`, so the convention is a parameter of the model rather
+ * than a re-implementation of it, and the picture cannot drift from what the tests
+ * measure.
+ */
+
+/** a held ring of charge, which is the structure these panels are looking for */
+const ring = (radius: number) => (w: World) => {
+ const C = (w.opts.N - 1) / 2;
+ for (let i = 0; i < 64; i++) {
+ const a = (2 * Math.PI * i) / 64;
+ w.add({
+ at: [Math.round(C + radius * Math.cos(a)), Math.round(C + radius * Math.sin(a)), C],
+ radius: 0, emits: i % 2 ? 1 : -1, duty: 1, absorbs: true,
+ });
+ }
+};
+
+const convention = (sign: "perNode" | "perAxis" | "perRay", why: string) =>
+ ({ height = 300 }: { height?: number }) => Panel({
+ height, note: `${sign} — ${why}`,
+ theory: withSign(GRAVITY_MAGNETISM, sign), N: 121, view: 26,
+ build: ring(14), control: () => {},
+ /*
+ * ONE TICK, NOT AN AVERAGE. These three are here to show that a single tick of
+ * the vacuum looks like noise whichever convention is chosen, which is the
+ * observation the averaged panels below are the answer to.
+ */
+ warm: 1, markers: false,
+ channels: () => [CHANNELS.charge()],
+ });
+
+export const PerNode = convention("perNode",
+ "one sign for the whole point, into all its axes at once");
+export const PerAxis = convention("perAxis",
+ "each axis signed on its own, so a point hands out independent ± pairs");
+export const PerRay = convention("perRay",
+ "every heading signed independently, which breaks the ± pair the rule states");
+
+/** the same field, averaged over time — and the ring comes out of the noise */
+export const MeanOccupancy = ({ height = 300 }: { height?: number }) => Panel({
+ height, note: "the same vacuum, AVERAGED over ticks — the structure is one object in a " +
+ "field that fills every point, so a single tick cannot show it and an average can",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 26,
+ build: ring(14), control: () => {},
+ warm: 200, markers: false,
+ channels: () => [CHANNELS.traffic()],
+});
+
+/** and with the sign kept, where it vanishes again — which is the honest half */
+export const MeanPolarity = ({ height = 300 }: { height?: number }) => Panel({
+ height, note: "the same average with the SIGN kept — the ring vanishes, because its charge " +
+ "is + on one lap and − on the next, so it is as unbiased in time as the vacuum is",
+ theory: GRAVITY_MAGNETISM, N: 121, view: 26,
+ build: ring(14), control: () => {},
+ warm: 200, markers: false,
+ channels: () => [CHANNELS.charge()],
+});
+
+/**
+ * A NEUTRAL WIRE — no net charge, no ray current, and a magnetic field anyway.
+ *
+ * The construction is the one `magnetostatics/neutral-wire` measures, not a picture
+ * drawn to look like it: alternating carriers along the axis, equal numbers of each,
+ * so there is NO net charge anywhere in it — and σu is +I ẑ for BOTH signs, so the
+ * labels add where the charges cancel. That is the whole point the section makes
+ * twice, and it is why B is the field that survives when E is exactly nothing.
+ */
+export const NeutralWire = ({ height = 300 }: { height?: number }) => Panel({
+ height, note: "a neutral wire — the + carriers drift one way and the − the other, so there " +
+ "is no net charge and no ray current, and there is a magnetic field anyway",
+ theory: LABELLED, N: 121, view: 26,
+ build: w => {
+ const C = (w.opts.N - 1) / 2, I = 0.5;
+ for (let y = 6; y < w.opts.N - 6; y++) {
+ const s = (y % 2 === 0 ? 1 : -1) as 1 | -1;
+ w.add({ at: [C, y, C], radius: 0.9, emits: s, u: [0, s * I, 0] });
+ }
+ },
+ control: () => {},
+ channels: () => [CHANNELS.magnetic(2), CHANNELS.charge()],
+});
diff --git a/orbitmines.com/src/routes/Physics/visuals/RING.tsx b/orbitmines.com/src/routes/Physics/visuals/RING.tsx
new file mode 100644
index 00000000..c8368022
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/RING.tsx
@@ -0,0 +1,258 @@
+/**
+ * THE RING, AND HOW MUCH OF THE GEOMETRY SURVIVES INTO IT.
+ *
+ * Two figures for one uncomfortable fact. The critical curve in this model is 4.63%
+ * larger than general relativity's; the thing a telescope measures is a bright
+ * emission ring some way outside that curve; and the second is not 4.63% larger unless
+ * the emission reaches all the way down, which the Event Horizon Telescope's own
+ * calibration says it does not.
+ *
+ * PROFILES the image each geometry casts, from one and the same plasma — where
+ * the ring peaks against where the critical curve is
+ * DILUTION the ratio an instrument would read, as a function of where the
+ * emission stops, for the three defensible ways of saying "the same
+ * plasma" in two different metrics
+ *
+ * THE SECOND IS READ, NOT COMPUTED. A ray trace across a sweep of inner radii is
+ * seconds of arithmetic and would hang the page on every paint, so `metric/ring-as-
+ * imaged` runs it once in the suite and records the table; this draws what it
+ * recorded, and says so if the report has not got it.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { entryOf, findingOf } from "./FIGURES";
+import {
+ RELATIVITY, COUNTED, criticalOf, iscoOf, profileOf, ringOf,
+} from "../RING";
+
+const BACK = "#08090d", FAINT = "#5a5f6e", GRID = "rgba(120,127,148,0.13)";
+const SEEN = "#eef0f5", MODEL = "#4aa8eb", RELAT = "#d4b48b", DATA = "#eb964a";
+
+const read = (name: string) => {
+ const f = findingOf("metric/ring-as-imaged", name);
+ return typeof f?.value === "number" ? f.value : NaN;
+};
+const EDGE = () => read("the emission inner edge that reproduces EHT's α = 11.55, in M");
+const OBSERVED = () => read("THE OBSERVABLE RATIO — plasma truncated at each geometry's own ISCO");
+
+const tag = (s: Surface, x: number, y: number, t: string, c: string, px = 9.5) => {
+ s.ctx.fillStyle = c;
+ s.ctx.font = `400 ${px}px ui-monospace, Menlo, monospace`;
+ s.ctx.fillText(t, x, y);
+};
+
+// ─── the two images ─────────────────────────────────────────────────────────
+
+/**
+ * ONE PLASMA, TWO GEOMETRIES, AND THE ONLY DIFFERENCE BETWEEN THE CURVES IS A AND B.
+ *
+ * The inner edge is put where EHT's α = 11.55 says it is, and in the count's geometry
+ * it is scaled to that geometry's own innermost stable orbit — the anchoring with a
+ * dynamical reason behind it. Both profiles are normalised to their own peak, because
+ * the question is where the ring is and not how bright it is.
+ */
+const profiles = (s: Surface) => {
+ const { ctx } = s;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, s.width, s.height);
+ const L = 50, R = 16, Tp = 24, B = 34;
+ const w = s.width - L - R, h = s.height - Tp - B;
+ const XLO = 3, XHI = 13;
+ const X = (b: number) => L + w * (b - XLO) / (XHI - XLO);
+ const Y = (v: number) => Tp + h * (1 - v);
+
+ const Rin = EDGE();
+ if (!Number.isFinite(Rin)) {
+ tag(s, L, Tp + 20, "the inner edge is NOT IN THE REPORT — run metric/ring-as-imaged", "#e0685f", 11);
+ return;
+ }
+ const scale = iscoOf(COUNTED).areal / iscoOf(RELATIVITY).areal;
+
+ ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+ ctx.font = "400 10px ui-monospace, Menlo, monospace";
+ for (let b = 4; b <= XHI; b += 1) {
+ ctx.beginPath(); ctx.moveTo(X(b), Tp); ctx.lineTo(X(b), Tp + h); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "center";
+ ctx.fillText(String(b), X(b), Tp + h + 15);
+ }
+ ctx.textAlign = "left";
+
+ const each = [
+ { g: RELATIVITY, Rin, col: RELAT, name: "general relativity" },
+ { g: COUNTED, Rin: Rin * scale, col: MODEL, name: "the count" },
+ ].map(o => {
+ const p = profileOf(o.g, { Rin: o.Rin, Rout: o.Rin * 12, gamma: 3 }, XHI + 2, 460, 520);
+ const peak = ringOf(p);
+ const top = Math.max(...p.I);
+ return { ...o, p, peak, top, crit: criticalOf(o.g).b };
+ });
+
+ for (const o of each) {
+ // the critical curve, which is NOT where the ring is
+ ctx.strokeStyle = o.col; ctx.globalAlpha = 0.45; ctx.lineWidth = 1;
+ ctx.setLineDash([2, 3]);
+ ctx.beginPath(); ctx.moveTo(X(o.crit), Tp); ctx.lineTo(X(o.crit), Tp + h); ctx.stroke();
+ ctx.setLineDash([]); ctx.globalAlpha = 1;
+
+ ctx.strokeStyle = o.col; ctx.lineWidth = 2.1;
+ ctx.beginPath();
+ o.p.b.forEach((b, i) => {
+ const y = Y(o.p.I[i] / o.top);
+ if (i === 0) ctx.moveTo(X(b), y); else ctx.lineTo(X(b), y);
+ });
+ ctx.stroke();
+
+ // and where it peaks, which is what a fitter would call the ring
+ ctx.fillStyle = o.col;
+ ctx.beginPath(); ctx.arc(X(o.peak.peak), Y(1), 3.4, 0, 7); ctx.fill();
+ ctx.strokeStyle = o.col; ctx.globalAlpha = 0.5; ctx.lineWidth = 1;
+ ctx.beginPath(); ctx.moveTo(X(o.peak.peak), Y(1)); ctx.lineTo(X(o.peak.peak), Tp + h);
+ ctx.stroke(); ctx.globalAlpha = 1;
+ }
+
+ const [gr, ct] = each;
+ const lx = X(7.6); // clear of the peak, which is the busy half
+ tag(s, lx, Tp + 14, `general relativity — critical curve ${gr.crit.toFixed(3)} M, ring peaks at ${gr.peak.peak.toFixed(3)} M`, RELAT);
+ tag(s, lx, Tp + 27, `the count — critical curve ${ct.crit.toFixed(3)} M, ring peaks at ${ct.peak.peak.toFixed(3)} M`, MODEL);
+ tag(s, lx, Tp + 44, `the critical curves differ by ${((ct.crit / gr.crit - 1) * 100).toFixed(2)}% — the RINGS by ${((ct.peak.peak / gr.peak.peak - 1) * 100).toFixed(2)}%`, SEEN);
+ tag(s, lx, Tp + 57, `dotted = the critical curve · solid dot = the ring`, FAINT, 8.5);
+ tag(s, lx, Tp + 68, `plasma from ${Rin.toFixed(2)} M outward, ε ∝ R⁻³, optically thin, static`, FAINT, 8.5);
+
+ ctx.fillStyle = FAINT; ctx.textAlign = "center";
+ ctx.font = "400 10px ui-monospace, Menlo, monospace";
+ ctx.fillText("impact parameter b [GM/c²]", L + w / 2, s.height - 8);
+ ctx.textAlign = "left";
+ ctx.fillText("brightness", 6, 16);
+};
+
+export const RingProfiles = ({ height = 320 }: { height?: number } = {}) =>
+
+
;
+
+// ─── and how much survives ──────────────────────────────────────────────────
+
+/**
+ * THE FIGURE THE WHOLE ARGUMENT COMES DOWN TO.
+ *
+ * Horizontally: where the emission stops, read as the α it produces in general
+ * relativity — so the x-axis is in the same units EHT calibrate in, and their
+ * α = 11.55 is a vertical line on it. Vertically: the ratio an instrument would
+ * measure between the two geometries.
+ *
+ * At the left edge, where emission reaches the photon sphere, all three anchorings
+ * meet the geometric 4.63%: the ring IS the critical curve there. Everywhere to the
+ * right of that they fan out, and EHT's own α sits in the fan — where the answer is
+ * anything from 1% to 6% depending on an assumption about plasma that this model has
+ * no way to fix.
+ */
+const dilution = (s: Surface) => {
+ const { ctx } = s;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, s.width, s.height);
+ const L = 52, R = 16, Tp = 22, B = 34;
+ const w = s.width - L - R, h = s.height - Tp - B;
+ const XLO = 10, XHI = 17, YLO = 0.995, YHI = 1.085;
+ const X = (a: number) => L + w * (a - XLO) / (XHI - XLO);
+ const Y = (v: number) => Tp + h * (1 - (v - YLO) / (YHI - YLO));
+
+ const e = entryOf("metric/ring-as-imaged");
+ if (!e?.table) {
+ tag(s, L, Tp + 20, "the sweep is NOT IN THE REPORT — run metric/ring-as-imaged", "#e0685f", 11);
+ return;
+ }
+ const col = (n: string) => e.table!.columns.indexOf(n);
+ const rows = e.table.rows.map(r => ({
+ a: Number(r[col("α in relativity")]),
+ areal: Number(r[col("ratio · areal")]),
+ isco: Number(r[col("ratio · ISCO")]),
+ photon: Number(r[col("ratio · photon")]),
+ })).filter(r => isFinite(r.a)).sort((p, q) => p.a - q.a);
+
+ ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+ ctx.font = "400 10px ui-monospace, Menlo, monospace";
+ for (const v of [1.00, 1.02, 1.04, 1.06, 1.08]) {
+ ctx.beginPath(); ctx.moveTo(L, Y(v)); ctx.lineTo(L + w, Y(v)); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "right";
+ ctx.fillText(v.toFixed(2), L - 6, Y(v) + 3);
+ }
+ for (let a = 10; a <= XHI; a += 1) {
+ ctx.beginPath(); ctx.moveTo(X(a), Tp); ctx.lineTo(X(a), Tp + h); ctx.stroke();
+ ctx.fillStyle = FAINT; ctx.textAlign = "center";
+ ctx.fillText(String(a), X(a), Tp + h + 15);
+ }
+ ctx.textAlign = "left";
+
+ // the geometric effect, which is the ceiling this cannot exceed and rarely reaches
+ const geo = criticalOf(COUNTED).b / criticalOf(RELATIVITY).b;
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 1.6; ctx.setLineDash([5, 4]);
+ ctx.beginPath(); ctx.moveTo(L, Y(geo)); ctx.lineTo(L + w, Y(geo)); ctx.stroke();
+ ctx.setLineDash([]);
+ // and no effect at all
+ ctx.strokeStyle = RELAT; ctx.lineWidth = 1.4;
+ ctx.beginPath(); ctx.moveTo(L, Y(1)); ctx.lineTo(L + w, Y(1)); ctx.stroke();
+
+ // where EHT's calibration puts the emission
+ ctx.strokeStyle = DATA; ctx.lineWidth = 1.6; ctx.setLineDash([2, 3]);
+ ctx.beginPath(); ctx.moveTo(X(11.55), Tp); ctx.lineTo(X(11.55), Tp + h); ctx.stroke();
+ ctx.setLineDash([]);
+
+ const lines: [keyof typeof rows[0], string, string][] = [
+ ["photon", "#c98bd4", "inner edge scaled to each photon sphere"],
+ ["isco", MODEL, "inner edge at each geometry's own ISCO"],
+ ["areal", "#6fd39b", "inner edge at the same areal radius"],
+ ];
+ for (const [k, c] of lines) {
+ ctx.strokeStyle = c; ctx.lineWidth = 2.1;
+ ctx.beginPath();
+ rows.forEach((r, i) => {
+ const y = Y(Math.min(YHI, Math.max(YLO, r[k] as number)));
+ if (i === 0) ctx.moveTo(X(r.a), y); else ctx.lineTo(X(r.a), y);
+ });
+ ctx.stroke();
+ for (const r of rows) {
+ ctx.fillStyle = c;
+ ctx.beginPath(); ctx.arc(X(r.a), Y(Math.min(YHI, Math.max(YLO, r[k] as number))), 2, 0, 7);
+ ctx.fill();
+ }
+ }
+
+ tag(s, L + 6, Y(1.081), `the geometry's own 4.63% — reached only where emission goes all the way down`, SEEN);
+ let y = 1.0715;
+ for (const [, c, label] of lines) { tag(s, L + 6, Y(y), label, c); y -= 0.0045; }
+ tag(s, X(11.55) + 6, Y(1.003), "EHT's α = 11.55", DATA);
+ const obs = OBSERVED();
+ if (Number.isFinite(obs))
+ tag(s, X(11.55) + 6, Y(obs + 0.0045), `→ ${((obs - 1) * 100).toFixed(1)}% at the ISCO anchoring`, MODEL);
+ tag(s, L + 6, Y(1.0005), "no difference from general relativity at all", RELAT);
+
+ ctx.fillStyle = FAINT; ctx.textAlign = "center";
+ ctx.font = "400 10px ui-monospace, Menlo, monospace";
+ ctx.fillText("where the emission stops, read as the α it produces in general relativity",
+ L + w / 2, s.height - 8);
+ ctx.textAlign = "left";
+ ctx.fillText("ring ratio", 6, 16);
+};
+
+export const RingDilution = ({ height = 330 }: { height?: number } = {}) =>
+
+ the same plasma around both geometries — and the rings are closer together than
+ the critical curves are, because a ring is the image of matter outside the curve
+
+
+ ({ frame: (s: Surface) => profiles(s) })} />
+
+
+
;
diff --git a/orbitmines.com/src/routes/Physics/visuals/SCALE.tsx b/orbitmines.com/src/routes/Physics/visuals/SCALE.tsx
new file mode 100644
index 00000000..003d12f2
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/SCALE.tsx
@@ -0,0 +1,215 @@
+/**
+ * HOW BIG A MAGNET CAN GET, AND HOW STRONG A FORCE CAN GET — the two scale
+ * questions the magnetism arc ends on, drawn because the shape of each is the
+ * point and a table hides it.
+ *
+ * These two used to sit in the archive with `const CYCLE = 8, DEG = 26, SHEET = 8`
+ * at the top of the file and the model's own magneton written in as the literal
+ * 0.0794. Both are now read off `CONTINUOUS.ts`, which reads them off the geometry
+ * `DISCRETE.ts` is running — so changing the lattice moves the blue line instead of
+ * leaving it where a cubic-26 run once put it. That was the whole of what these
+ * owed, and it is the reason they were the last two panels outside `visuals/`.
+ *
+ * The palette is the article's, unchanged: WHAT IS MEASURED in white, TEXTBOOK
+ * ELECTROMAGNETISM in orange, THIS MODEL in blue, and nothing else gets a strong
+ * colour. On the gravitational side those three lie on top of each other. Here the
+ * second panel is forty-two decades of them not doing that, which is the one number
+ * this half of the article openly owes.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { constants } from "../CONTINUOUS";
+
+const INK = "#c8cbd4", FAINT = "#5a5f6e", GRID = "rgba(255,255,255,0.055)";
+const MODEL = "#4aa8eb", DATA = "#eb964a", SEEN = "#eef0f5";
+const BACK = "#08090d";
+
+/** the lattice's own constants — the same object every test and every other panel reads */
+const k = constants();
+
+// ---------------------------------------------------------------------------
+// the article's drawing helpers, kept local so the panel stands on its own
+
+const frame = (s: Surface, pad = 46, bottom = 36) => {
+ const { ctx, width, height } = s;
+ ctx.clearRect(0, 0, width, height);
+ ctx.fillStyle = BACK;
+ ctx.fillRect(0, 0, width, height);
+ return {
+ x0: pad, x1: width - 14, y0: 12, y1: height - bottom,
+ w: width - 14 - pad, h: height - bottom - 12,
+ };
+};
+
+const tag = (s: Surface, x: number, y: number, text: string, css: string, size = 11) => {
+ s.ctx.fillStyle = css;
+ s.ctx.font = `500 ${size}px ui-sans-serif, system-ui, sans-serif`;
+ s.ctx.fillText(text, x, y);
+};
+
+const mono = (s: Surface, x: number, y: number, text: string, css: string, size = 10) => {
+ s.ctx.fillStyle = css;
+ s.ctx.font = `400 ${size}px ui-monospace, Menlo, monospace`;
+ s.ctx.fillText(text, x, y);
+};
+
+const centred = (s: Surface, x: number, y: number, text: string, css: string, size = 10) => {
+ s.ctx.textAlign = "center";
+ mono(s, x, y, text, css, size);
+ s.ctx.textAlign = "left";
+};
+
+const under = (s: Surface, box: ReturnType
+ how much of the 4.63% an instrument actually sees — against where the emission
+ stops, and the spread is wider than the effect
+
+
+ ({ frame: (s: Surface) => dilution(s) })} />
+
+
+
;
+
+// ---------------------------------------------------------------------------
+// 1. SCALE — from one electron to a magnetar
+//
+// The ceiling is µ/M ≤ µ_B/m_e, a volume law, and a big body screens itself so only
+// a skin gets out. Neither is close to binding anywhere, which is a null result in
+// the useful direction: SCALE IS NOT WHAT STOPS THIS.
+
+type Body = { name: string; perkg: number; kind: "lab" | "sky" };
+
+/** measured moment per kilogram — laboratory materials and the sky, both literature */
+const BODIES: Body[] = [
+ { name: "iron, saturated", perkg: 217.3, kind: "lab" },
+ { name: "N52", perkg: 153.8, kind: "lab" },
+ { name: "ferrite", perkg: 65.0, kind: "lab" },
+ { name: "the Sun", perkg: 1.70e-1, kind: "sky" },
+ { name: "Jupiter", perkg: 8.17e-1, kind: "sky" },
+ { name: "a magnetar", perkg: 6.22e-1, kind: "sky" },
+ { name: "a neutron star", perkg: 6.22e-4, kind: "sky" },
+ { name: "the Earth", perkg: 1.32e-2, kind: "sky" },
+];
+
+/** µ_B/m_e in A·m² per kg — the most moment a kilogram of anything can carry */
+const CEILING = 1.018e7;
+
+/**
+ * AND THE MODEL'S OWN MAGNETON, AS A FRACTION OF THAT CEILING.
+ *
+ * A source's loop is a ring of the lattice: it comes round in `CYCLE` ticks, so the
+ * radius that ring encloses is `(CYCLE·Ḡ/2π)·λ̄_C` and the moment it makes is that
+ * fraction of one Bohr magneton per electron mass. Both symbols in it are the
+ * lattice's — the ring size and the gravitational constant — so this is a count, not
+ * a fit, and it MOVES with the geometry. On cubic 26 it is 8·0.062351/2π = 0.0794,
+ * which is the literal that used to be typed here; on the fcc 12 the book now runs
+ * on it is a different number, and the line below goes where that says.
+ */
+const MAGNETON = k.CYCLE * k.gravitational() / (2 * Math.PI);
+
+const ceiling = (s: Surface) => {
+ const box = frame(s, 54, 40);
+ const { ctx } = s;
+
+ // log axis from 10⁻⁴ to 10⁸ A·m²/kg
+ const LO = -4, HI = 8;
+ const X = (v: number) => box.x0 + box.w * (Math.log10(v) - LO) / (HI - LO);
+
+ ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+ for (let d = LO; d <= HI; d += 2) {
+ const x = X(Math.pow(10, d));
+ ctx.beginPath(); ctx.moveTo(x, box.y0 + 32); ctx.lineTo(x, box.y1); ctx.stroke();
+ centred(s, x, box.y1 + 14, `10${d < 0 ? "⁻" : ""}${["⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸"][Math.abs(d)]}`, FAINT, 9);
+ }
+
+ // the ceiling
+ const cx = X(CEILING);
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 2; ctx.setLineDash([5, 3]);
+ ctx.beginPath(); ctx.moveTo(cx, box.y0 + 32); ctx.lineTo(cx, box.y1); ctx.stroke();
+ ctx.setLineDash([]);
+ tag(s, cx - 118, box.y0 + 26, "the ceiling, µ_B/m_e", SEEN, 10);
+
+ // and the model's own magneton, off the geometry rather than off a transcription
+ const mx = X(CEILING * MAGNETON);
+ ctx.strokeStyle = MODEL; ctx.lineWidth = 1.4; ctx.setLineDash([3, 3]);
+ ctx.beginPath(); ctx.moveTo(mx, box.y0 + 32); ctx.lineTo(mx, box.y1); ctx.stroke();
+ ctx.setLineDash([]);
+ tag(s, mx - 168, box.y0 + 12, `the model's own, ×${MAGNETON.toFixed(4)} (${k.geometry})`, MODEL, 10);
+
+ const rh = (box.h - 34) / BODIES.length;
+ [...BODIES].sort((a, b) => b.perkg - a.perkg).forEach((b, i) => {
+ const y = box.y0 + 34 + rh * (i + 0.5);
+ const x = X(b.perkg);
+
+ ctx.strokeStyle = GRID;
+ ctx.beginPath(); ctx.moveTo(box.x0, y); ctx.lineTo(box.x1, y); ctx.stroke();
+
+ ctx.fillStyle = b.kind === "lab" ? DATA : SEEN;
+ ctx.beginPath(); ctx.arc(x, y, 4, 0, 2 * Math.PI); ctx.fill();
+
+ mono(s, x + 9, y + 4, `${b.name} ${(b.perkg / CEILING).toExponential(1)} of it`,
+ b.kind === "lab" ? DATA : INK, 10);
+ });
+
+ under(s, box, "moment per kilogram — nothing anywhere gets within 10⁻⁴ of what the model allows");
+};
+
+/** the ceiling, at every scale there is, and how much room is left under it */
+export const Ceiling = ({ height = 250 }: { height?: number }) =>
+ {note}
+
+ ({ frame: paint })} />
+
+
+
;
+
+export const ShadowOverlay = ({ height = 320 }: { height?: number } = {}) =>
+
+ the same mass, the same camera — general relativity left of the seam, the
+ annihilation count right. The bright ring is where rays pile up; the dashed arcs
+ are the two critical radii, and the step at the seam is the {(2 * Math.E / (3 * Math.sqrt(3)) * 100 - 100).toFixed(2)}% the model predicts
+
+
+ ({ frame: seam(SCHWARZSCHILD, COUNTED) })} />
+
+
+
;
+
+/**
+ * THE ROUTES THEMSELVES — what a ray does near the hole, rather than what it looks
+ * like from far away.
+ *
+ * The shadow figures answer "which rays come back". This answers "by what path", which
+ * is where the photon sphere stops being a number and becomes a place: rays aimed a
+ * little wide of the critical impact parameter wind several times round before
+ * leaving, and a little narrow they wind round and fall in. THAT WINDING IS WHY THE
+ * RING IS BRIGHT — many paths pile into the same narrow range of directions.
+ *
+ * INTEGRATED IN φ RATHER THAN IN r, so a turning point is an ordinary place on the
+ * path rather than the singular one it is for dr/dφ. The same lesson as the perihelion
+ * advance, which cost a wrong answer before it was learned.
+ */
+const route = (m: Metric, b: number, steps = 4000) => {
+ let r = 40, phi = Math.PI, inward = true;
+ const pts: [number, number][] = [];
+ const dphi = (2 * Math.PI * 3) / steps;
+ for (let i = 0; i < steps; i++) {
+ const t = turn(m, r);
+ const q = (t * t) / (b * b) - 1;
+ if (q <= 0) inward = false; // a turning point: back out
+ const drdphi = (inward ? -1 : 1) * r * Math.sqrt(Math.max(q, 0));
+ r += drdphi * dphi;
+ phi += dphi;
+ if (r < 0.12 || r > 60) break;
+ pts.push([r * Math.cos(phi), r * Math.sin(phi)]);
+ }
+ return { pts, escaped: r > 40 };
+};
+
+export const Routes = ({ height = 320 }: { height?: number } = {}) =>
+
+ the two laid on top of each other — dark where both cast a shadow, pale where
+ neither does, and coloured only in the annulus between the two critical radii.
+ That ring is the whole of the disagreement: {SCHWARZSCHILD.crit.toFixed(3)} M
+ against {COUNTED.crit.toFixed(3)} M
+
+
+ ({ frame: overlay(COUNTED, SCHWARZSCHILD) })} />
+
+
+
;
+
+// ─── against the two images there are ───────────────────────────────────────
+
+/**
+ * WHAT THE EVENT HORIZON TELESCOPE HAS ALREADY SAID ABOUT IT.
+ *
+ * The derivation gives one number and no others: a shadow 4.63% larger than general
+ * relativity's at the same mass. The collaboration publishes exactly the quantity that
+ * number is a prediction for —
+ *
+ * δ = θ_measured / θ_Schwarzschild − 1
+ *
+ * with θ_Schwarzschild built from a mass and a distance measured some other way. That
+ * is "measure the mass from orbits and the shadow from imaging", which is the whole of
+ * the test, so the panel is one axis with δ on it and everything else is annotation.
+ *
+ * THREE ROWS FOR TWO OBJECTS. Sgr A* appears twice because the same image is measured
+ * against two independent mass calibrations, VLTI and Keck; those two cannot be
+ * averaged with each other, though either can be averaged with M87*.
+ *
+ * AND THE AMBER BAND IS THE HONEST PART. General relativity's own δ is not a point:
+ * Kerr runs from −0.08 at high spin down to 0 at none, so the range relativity already
+ * covers is nearly twice the excess being looked for. A shadow measured against an
+ * orbital mass therefore cannot settle this alone — it needs a spin from somewhere
+ * else, or an object known to be spinning slowly. The prediction stays falsifiable and
+ * stops being a one-measurement test, and drawing the band is the only way to say that
+ * without the reader having to take it on trust.
+ */
+type Image = { of: string; delta: number; e: number; note: string };
+const IMAGES: Image[] = [
+ { of: "M87*", delta: -0.01, e: 0.17,
+ note: "EHT 2019 VI · Gebhardt+2011's stellar-dynamical mass" },
+ { of: "Sgr A*", delta: -0.08, e: 0.09, note: "EHT 2022 VI · VLTI orbital mass" },
+ { of: "Sgr A*", delta: -0.04, e: 0.09, note: "EHT 2022 VI · Keck orbital mass" },
+];
+
+const EXCESS = (2 * Math.E) / (3 * Math.sqrt(3)) - 1;
+const KERR_LO = -0.08;
+
+/**
+ * AND THE MODEL GETS A BAND TOO, WHICH IS NOT THE SAME KIND OF BAND.
+ *
+ * The amber one is SPIN: Kerr's δ genuinely runs from −0.08 to 0 as a real black hole
+ * turns, so general relativity does not predict a number, it predicts a range, and the
+ * range is a property of the object.
+ *
+ * The blue one is IGNORANCE. `metric/ring-as-imaged` traces the ring an optically thin
+ * plasma casts around each geometry and finds the observable ratio depends on where
+ * that plasma sits — 1.010 anchored at the same areal radius, 1.038 at each geometry's
+ * own ISCO, 1.062 scaled to each photon sphere. Nothing in this model picks between
+ * them. So the width is not something the black hole is doing, it is something this
+ * page does not know, and drawing the two the same way would be a lie of composition.
+ * They are labelled apart, and the model's own spin range is not in there at all
+ * because nothing here has a rotating solution to take it from.
+ */
+const readRing = (name: string) => {
+ const f = findingOf("metric/ring-as-imaged", name);
+ return typeof f?.value === "number" ? f.value : NaN;
+};
+const OBSERVED = () => readRing(
+ "THE OBSERVABLE RATIO — plasma truncated at each geometry's own ISCO") - 1;
+const BAND_LO = () => readRing(
+ "the observable ratio, plasma at the same areal radius in both") - 1;
+const BAND_HI = () => readRing(
+ "the observable ratio, plasma scaled to each photon sphere") - 1;
+
+const eht = (s: Surface) => {
+ const { ctx } = s;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, s.width, s.height);
+ const L = 58, R = 18, T = 46, B = 46;
+ const w = s.width - L - R, h = s.height - T - B;
+ const LO = -0.30, HI = 0.30;
+ const X = (d: number) => L + w * (d - LO) / (HI - LO);
+ const rowY = (i: number) => T + h * (i + 0.65) / (IMAGES.length + 0.6);
+
+ ctx.font = "400 10px ui-monospace, Menlo, monospace";
+ ctx.strokeStyle = "rgba(120,127,148,0.13)"; ctx.lineWidth = 1;
+ for (let d = -0.3; d <= 0.301; d += 0.1) {
+ ctx.beginPath(); ctx.moveTo(X(d), T); ctx.lineTo(X(d), T + h); ctx.stroke();
+ ctx.fillStyle = "#5a5f6e"; ctx.textAlign = "center";
+ ctx.fillText(`${d > 0.001 ? "+" : ""}${d.toFixed(1)}`, X(d), T + h + 16);
+ }
+
+ // the range general relativity itself covers, over spin and viewing angle
+ ctx.fillStyle = "rgba(212,180,139,0.10)";
+ ctx.fillRect(X(KERR_LO), T, X(0) - X(KERR_LO), h);
+ ctx.strokeStyle = "#d4b48b"; ctx.lineWidth = 1.8;
+ ctx.beginPath(); ctx.moveTo(X(0), T); ctx.lineTo(X(0), T + h); ctx.stroke();
+
+ // the geometry alone — a sharp line, and no longer the thing to compare against
+ ctx.strokeStyle = "#4aa8eb"; ctx.globalAlpha = 0.40; ctx.lineWidth = 1.2;
+ ctx.setLineDash([2, 4]);
+ ctx.beginPath(); ctx.moveTo(X(EXCESS), T); ctx.lineTo(X(EXCESS), T + h); ctx.stroke();
+ ctx.setLineDash([]); ctx.globalAlpha = 1;
+
+ // and what an instrument would see: a band, because the plasma is not pinned down
+ const lo = BAND_LO(), hi = BAND_HI(), mid = OBSERVED();
+ if (Number.isFinite(lo) && Number.isFinite(hi)) {
+ ctx.fillStyle = "rgba(74,168,235,0.13)";
+ ctx.fillRect(X(lo), T, X(hi) - X(lo), h);
+ }
+ if (Number.isFinite(mid)) {
+ ctx.strokeStyle = "#4aa8eb"; ctx.lineWidth = 2.2; ctx.setLineDash([6, 3]);
+ ctx.beginPath(); ctx.moveTo(X(mid), T); ctx.lineTo(X(mid), T + h); ctx.stroke();
+ ctx.setLineDash([]);
+ }
+
+ IMAGES.forEach((im, i) => {
+ const y = rowY(i);
+ ctx.strokeStyle = "#eef0f5"; ctx.lineWidth = 1.4;
+ ctx.beginPath(); ctx.moveTo(X(im.delta - im.e), y); ctx.lineTo(X(im.delta + im.e), y); ctx.stroke();
+ for (const q of [im.delta - im.e, im.delta + im.e]) {
+ ctx.beginPath(); ctx.moveTo(X(q), y - 4); ctx.lineTo(X(q), y + 4); ctx.stroke();
+ }
+ ctx.fillStyle = "#eef0f5";
+ ctx.beginPath(); ctx.arc(X(im.delta), y, 3.2, 0, 2 * Math.PI); ctx.fill();
+
+ ctx.textAlign = "right"; ctx.font = "400 11px ui-monospace, Menlo, monospace";
+ ctx.fillText(im.of, L - 8, y + 4);
+ /*
+ * THE ANNOTATION IS RIGHT-ALIGNED TO THE FRAME, not hung off the end of the bar.
+ * M87*'s error is ±0.17 and its bar reaches most of the way across, so text placed
+ * after it ran off the panel and was cut in half — which is how the first render
+ * of this figure came out.
+ */
+ ctx.textAlign = "right"; ctx.font = "400 8.5px ui-monospace, Menlo, monospace";
+ ctx.fillStyle = "#5a5f6e";
+ ctx.fillText(im.note, s.width - R, y - 4);
+ const at = Number.isFinite(mid) ? mid : EXCESS;
+ ctx.fillText(`${(Math.abs(at - im.delta) / im.e).toFixed(2)}σ from this model,` +
+ ` ${(Math.abs(im.delta) / im.e).toFixed(2)}σ from relativity`, s.width - R, y + 8);
+ });
+
+ ctx.font = "400 9.5px ui-monospace, Menlo, monospace";
+ ctx.textAlign = "left";
+ ctx.fillStyle = "#4aa8eb";
+ ctx.fillText(Number.isFinite(mid)
+ ? `this model, AS IMAGED — δ = +${mid.toFixed(4)}, and the blue band is where the plasma could put it`
+ : "this model — the ray-traced ring is NOT IN THE REPORT", L + 4, T - 32);
+ ctx.fillStyle = "rgba(74,168,235,0.55)";
+ ctx.fillText(`the faint line is the geometry alone, δ = 2e/3√3 − 1 = +${EXCESS.toFixed(4)} — not what a telescope reads`,
+ L + 4, T - 20);
+ ctx.fillStyle = "#d4b48b";
+ ctx.fillText("general relativity — δ = 0 at no spin, and the amber band is Kerr's own range over spin",
+ L + 4, T - 8);
+ ctx.fillStyle = "#5a5f6e"; ctx.textAlign = "center";
+ ctx.fillText("δ = measured shadow / relativity's shadow at the same mass − 1",
+ L + w / 2, s.height - 8);
+};
+
+export const ShadowAgainstEht = ({ height = 300 }: { height?: number } = {}) =>
+
+ the paths themselves, in the metric the count gives — aimed a little wide of the
+ critical impact parameter a ray winds round and leaves, a little narrow and it
+ winds round and falls in. That winding is why the ring is bright
+
+
+ ({
+ frame: (s: Surface) => {
+ const { ctx, width, height: H } = s;
+ ctx.clearRect(0, 0, width, H);
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, H);
+ const SPAN = 22, k = Math.min(width, H) / (2 * SPAN);
+ const cx = width / 2, cy = H / 2;
+ const bc = COUNTED.crit;
+ for (let i = -6; i <= 6; i++) {
+ const b = bc * (1 + i * 0.045);
+ const { pts, escaped } = route(COUNTED, b);
+ if (pts.length < 2) continue;
+ ctx.strokeStyle = escaped ? "rgba(61,220,255,0.55)" : "rgba(255,122,69,0.55)";
+ ctx.lineWidth = 1;
+ ctx.beginPath();
+ pts.forEach(([x, y], j) =>
+ j ? ctx.lineTo(cx + x * k, cy - y * k) : ctx.moveTo(cx + x * k, cy - y * k));
+ ctx.stroke();
+ }
+ ctx.setLineDash([3, 4]); ctx.strokeStyle = "rgba(140,147,168,0.65)";
+ ctx.beginPath(); ctx.arc(cx, cy, bc * k, 0, 2 * Math.PI); ctx.stroke();
+ ctx.setLineDash([]);
+ ctx.fillStyle = "rgba(200,205,220,0.8)";
+ ctx.beginPath(); ctx.arc(cx, cy, 2.5, 0, 2 * Math.PI); ctx.fill();
+ ctx.font = "11px system-ui, sans-serif"; ctx.textAlign = "left";
+ ctx.fillStyle = "#3ddcff"; ctx.fillText("escapes", 12, 16);
+ ctx.fillStyle = "#ff7a45"; ctx.fillText("captured", 12, 31);
+ ctx.fillStyle = "#5a5f6e";
+ ctx.fillText(`dashed: b = 2e M = ${bc.toFixed(3)} M`, 12, H - 12);
+ },
+ })} />
+
+
+
;
diff --git a/orbitmines.com/src/routes/Physics/visuals/SHELTER.tsx b/orbitmines.com/src/routes/Physics/visuals/SHELTER.tsx
new file mode 100644
index 00000000..e7d5a1eb
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/SHELTER.tsx
@@ -0,0 +1,721 @@
+/**
+ * THE TWO GRAVITY PANELS FROM THE ARCHIVE, ON THE NEW CORE.
+ *
+ * These are `grid.tsx`'s `LatticeAttract/Repel/Inert` and `wander.tsx`'s
+ * `WanderGravity`, rebuilt so that they run `DISCRETE.ts` instead of their own
+ * automaton. The layout, the split, the labels and the argument are unchanged — what
+ * changed is that a picture of the model is now a picture of THE model. The archive's
+ * versions were two separate simulators, which is how the old panels came to be
+ * drawing a vacuum a fifth of the derived density while every test said otherwise.
+ *
+ * WHY BOTH ARE SPLIT DOWN THE MIDDLE, which is the whole point of the pair:
+ *
+ * A SINGLE TICK IS NOISE. At this occupancy the shot noise across a cell is far
+ * bigger than the shortfall a body leaves, so the left half is static with two
+ * holes in it. The shortfall is not visible in any one tick and never will be.
+ *
+ * IT IS VISIBLE IN THE AVERAGE, which is the right half, and it comes out of the
+ * noise as √n. That is not an artefact of the drawing — it is what it means for
+ * gravity to be the weakest thing there is.
+ *
+ * AND WHAT WAS TRIED FIRST, kept because it is worth knowing. The obvious way to
+ * isolate the shortfall is to run two copies, one with the bodies and one without, on
+ * the same draws, and subtract. It does not work: a lattice gas is CHAOTIC, so a
+ * single changed bit spreads across the light cone at full amplitude within a few
+ * dozen ticks and the difference is decorrelated noise rather than the response.
+ * Common random numbers are a technique for smooth systems. Averaging is what is left.
+ *
+ * THE ARROWS ARE MEASURED, not drawn on: the momentum actually arriving at each body,
+ * summed over its cells and over every tick since the start, read straight off
+ * `Source.absorbed`. They come out pointing at each other, which is the claim.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { GRAVITY, GRAVITY_MAGNETISM, GEOMETRIES, Source, World } from "../DISCRETE";
+
+const BACK = "#08090d", FAINT = "#5a5f6e";
+const PLUS = "#4aa8eb", MINUS = "#eb964a";
+const SEEN = "#eef0f5", BAD = "#e0685f", GOOD = "#8bd48b", INK = "#c8cbd4";
+/** where the vacuum is destroyed SLOWER than it would be — the shadow, and the pull */
+const SHADE = "#5b8dd6";
+
+const GEOM = GEOMETRIES["square-8"];
+const N = 121, C = 60;
+
+type Two = { w: World; bodies: Source[]; sep: number; since?: Float64Array };
+
+const make = (qL: 1 | -1 | 0, qR: 1 | -1 | 0, sep: number, theory = GRAVITY_MAGNETISM, empty = false, settle = 0): Two => {
+ const w = new World({
+ /*
+ * WRAPPED, BECAUSE AN ABSORBING EDGE IS ITSELF A SHADOW. Rays leave at the
+ * boundary and never come back, so the vacuum annihilates less there — and once
+ * the panel drew deficit as well as excess, that edge came out as a bright blue
+ * frame around the whole box, far stronger than anything a body does. It was a
+ * picture of the boundary condition. A wrapped box has no edge to be short of.
+ */
+ theory, geometry: GEOM, N, seed: 20260817, boundary: "wrap",
+ });
+ /*
+ * THE VACUUM SETTLES BEFORE THE BODY ARRIVES, which is what makes the panel a
+ * picture of the body rather than of the box starting up. The snapshot taken at
+ * that instant is the zero everything after it is drawn against.
+ */
+ let since: Float64Array | undefined;
+ if (settle) {
+ for (let i = 0; i < settle; i++) w.tick();
+ since = new Float64Array(w.backend.size());
+ w.backend.forEachLocal(k => { since![k] = w.destroyed[k]; });
+ }
+ if (sep === 0) return { w, since, bodies: empty ? [] : [w.add({
+ at: [C, C], radius: 3, emits: qL, absorbs: true, duty: qL === 0 ? 0 : 1,
+ })], sep };
+ const one = (x: number, q: 1 | -1 | 0) => w.add({
+ at: [x, C], radius: 3, emits: q, absorbs: true, duty: q === 0 ? 0 : 1,
+ });
+ return { w, since, bodies: empty ? [] : [one(C - sep / 2, qL), one(C + sep / 2, qR)], sep };
+};
+
+const px = (w: World, k: number) => w.geometry.embed(w.backend.position(k));
+
+/**
+ * THE SPLIT PANEL. Left: one tick, which is mostly vacuum. Right: where space has
+ * been destroyed, AGAINST THE VACUUM'S OWN RATE.
+ *
+ * Normalising the right half to its peak makes the panels incomparable — the opposite
+ * case puts a narrow, intense band between the two, so scaling to its peak sends
+ * everything else to nothing, while the alike case has no band and its vacuum fills
+ * the frame. Both then look like the opposite of what they are. A force is an EXCESS
+ * over the rate the vacuum runs at anyway, so that is what is drawn: the far field is
+ * the zero and only what exceeds it is inked.
+ */
+const paint = (t: Two, sur: Surface, label: string, right: string) => {
+ const { ctx, width, height } = sur;
+ const w = t.w, g = w.geometry;
+ /** what has been destroyed, since whenever this panel's clock starts */
+ const D = t.since ? (k: number) => w.destroyed[k] - t.since![k] : (k: number) => w.destroyed[k];
+ const H = height - 26;
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+ const half = width / 2;
+ const s = Math.min(half / N, H / N);
+ const ox = (half - N * s) / 2, oy = 20 + (H - 20 - N * s) / 2;
+ const ox2 = half + (half - N * s) / 2;
+
+ // ── left: one tick of the model
+ w.backend.forEachLocal(k => {
+ if (w.isSource(k)) return;
+ let net = 0, n = 0;
+ for (let d = 0; d < g.DEG; d++) {
+ if (!w.backend.active(k, d)) continue;
+ net += w.backend.charge(k, d); n++;
+ }
+ if (!n) return;
+ const p = px(w, k);
+ ctx.globalAlpha = Math.min(0.9, 0.25 + n / g.DEG);
+ ctx.fillStyle = net > 0 ? PLUS : net < 0 ? MINUS : FAINT;
+ ctx.fillRect(ox + p[0] * s, oy + p[1] * s, Math.max(s, 1), Math.max(s, 1));
+ });
+ ctx.globalAlpha = 1;
+
+ // ── the vacuum's own rate, taken in the far field where nothing local happens
+ let bg = 0, bn = 0;
+ w.backend.forEachLocal(k => {
+ if (w.isSource(k)) return;
+ const p = px(w, k);
+ if (p[0] < 6 || p[1] < 6 || p[0] > N - 6 || p[1] > N - 6) return;
+ if (Math.hypot(p[0] - C, p[1] - C) < 34) return;
+ bg += D(k); bn++;
+ });
+ bg = bn ? bg / bn : 1;
+
+ /*
+ * AND IN UNITS OF THE FAR FIELD'S OWN SCATTER, not of a fixed percentage.
+ *
+ * The archive thresholded at 8% above the far-field mean, which worked there
+ * because its automaton's vacuum barely annihilated. THIS vacuum annihilates
+ * constantly — the far-field mean is 34 destructions a cell after 260 ticks — so a
+ * fixed 8% passes the vacuum's own shot noise everywhere and the panel came out a
+ * uniform red haze with the bodies lost in it. Measured: the band between two
+ * opposite charges is 13.0% above the far field and between two alike ones 10.2%,
+ * so the two cases are separated by rather less than the archive's picture implied,
+ * and the honest scale is the one that says how many times the vacuum's own
+ * fluctuation a reading is.
+ */
+ let v2 = 0, vn = 0;
+ w.backend.forEachLocal(k => {
+ if (w.isSource(k)) return;
+ const p = px(w, k);
+ if (p[0] < 6 || p[1] < 6 || p[0] > N - 6 || p[1] > N - 6) return;
+ if (Math.hypot(p[0] - C, p[1] - C) < 34) return;
+ const d = D(k) - bg; v2 += d * d; vn++;
+ });
+ const sd = vn ? Math.max(Math.sqrt(v2 / vn), 1e-9) : 1;
+
+ /*
+ * ── right: BOTH SIGNS, and the one that was missing is the whole of gravity.
+ *
+ * The archive inked only what EXCEEDED the far field, and so did the first version
+ * of this. That is right for the electric panels, where two opposite charges
+ * annihilate between them and pile destruction up in the gap. It renders GRAVITY
+ * INVISIBLE, because a gravitating body does the opposite: it EATS the rays that
+ * would have met behind it, so the vacuum downstream of it annihilates LESS than it
+ * otherwise would. The aggregate pressure is a SHORTFALL, and a panel that only
+ * draws excess draws everything about it except the thing it is.
+ *
+ * Measured on shells, against the far field at 300 ticks:
+ *
+ * two inert bodies, pure gravity r8 −7% r12 −12% r16 −11%
+ * two inert bodies, g+m r8 −10% r12 −13% r16 −12%
+ * two opposite charges, g+m r8 +11% r12 +11% r16 +7%
+ *
+ * So the shadow is a ring of DEFICIT around the pair, of about the same size as the
+ * electric excess and of the opposite sign. Both are drawn: red where space is
+ * being destroyed faster than the vacuum does anyway, blue where it is being
+ * destroyed slower — which is the shadow, and which is what a body falls toward.
+ */
+ /*
+ * AND AVERAGED OVER A NEIGHBOURHOOD, for exactly the reason the left half is
+ * averaged over time.
+ *
+ * Per cell, the shortfall is far under the vacuum's own scatter — the shell profile
+ * says −12% at r = 12 while a single cell's fluctuation is several times that, so
+ * cell-by-cell the panel is salt and pepper with the structure buried in it. A box
+ * average over ±B cells divides the noise by the number of cells in the box and
+ * leaves the structure alone, which is the same √n the time average buys. It is
+ * smoothing, not enhancement: nothing is scaled up, the noise is taken down.
+ */
+ const B = 3, W = (2 * B + 1) * (2 * B + 1);
+ const fld = new Float64Array(N * N).fill(NaN);
+ w.backend.forEachLocal(k => {
+ if (w.isSource(k)) return;
+ const p = px(w, k);
+ fld[Math.round(p[0]) * N + Math.round(p[1])] = D(k);
+ });
+ for (let x = B; x < N - B; x++) for (let y = B; y < N - B; y++) {
+ let sum = 0, n = 0;
+ for (let i = -B; i <= B; i++) for (let j = -B; j <= B; j++) {
+ const v = fld[(x + i) * N + (y + j)];
+ if (!Number.isNaN(v)) { sum += v; n++; }
+ }
+ if (n < W * 0.6) continue; // next to a body: not a fair average
+ const z = (sum / n - bg) / (sd / Math.sqrt(n));
+ if (Math.abs(z) < 2) continue; // two sigma of the SMOOTHED field
+ ctx.globalAlpha = Math.min(0.9, (Math.abs(z) - 2) * 0.16);
+ ctx.fillStyle = z > 0 ? BAD : SHADE;
+ ctx.fillRect(ox2 + x * s, oy + y * s, Math.max(s, 1), Math.max(s, 1));
+ }
+ ctx.globalAlpha = 1;
+
+ // the two bodies, on both halves
+ for (const base of [ox, ox2]) {
+ for (const b of t.bodies) {
+ const p = px(w, b.locals[0]);
+ let cx = 0, cy = 0;
+ for (const k of b.locals) { const q = px(w, k); cx += q[0]; cy += q[1]; }
+ cx /= b.locals.length; cy /= b.locals.length;
+ ctx.beginPath();
+ ctx.arc(base + cx * s, oy + cy * s, 3 * s, 0, 7);
+ ctx.fillStyle = b.emits === 0 ? "#2a2e38" : b.emits > 0 ? PLUS : MINUS;
+ ctx.fill();
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 1.2; ctx.stroke();
+ void p;
+ }
+ }
+
+ // ── the arrows: the momentum that actually arrived, on the averaged half
+ const scale = 26 / Math.max(...t.bodies.map(b => Math.hypot(...b.absorbed.slice(0, 2))), 1e-9);
+ t.bodies.forEach(b => {
+ let cx = 0, cy = 0;
+ for (const k of b.locals) { const q = px(w, k); cx += q[0]; cy += q[1]; }
+ cx /= b.locals.length; cy /= b.locals.length;
+ const fx = (b.absorbed[0] ?? 0) * scale, fy = (b.absorbed[1] ?? 0) * scale;
+ if (Math.hypot(fx, fy) < 3) return;
+ const x0 = ox2 + cx * s, y0 = oy + cy * s;
+ ctx.strokeStyle = GOOD; ctx.lineWidth = 1.8;
+ ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x0 + fx, y0 + fy); ctx.stroke();
+ const a = Math.atan2(fy, fx);
+ ctx.beginPath();
+ ctx.moveTo(x0 + fx, y0 + fy);
+ ctx.lineTo(x0 + fx - 6 * Math.cos(a - 0.4), y0 + fy - 6 * Math.sin(a - 0.4));
+ ctx.moveTo(x0 + fx, y0 + fy);
+ ctx.lineTo(x0 + fx - 6 * Math.cos(a + 0.4), y0 + fy - 6 * Math.sin(a + 0.4));
+ ctx.stroke();
+ });
+
+ ctx.font = "10px ui-monospace, monospace";
+ ctx.fillStyle = FAINT;
+ ctx.textAlign = "center";
+ ctx.fillText("one tick — mostly vacuum", half / 2, 14);
+ ctx.fillText(right, half + half / 2, 14);
+ ctx.fillStyle = "#8a8f9e";
+ ctx.fillText("red: destroyed faster blue: SLOWER — the shadow", half + half / 2, height - 10);
+ ctx.fillStyle = FAINT;
+ ctx.textAlign = "left";
+ ctx.fillText(label, 10, height - 10);
+ ctx.textAlign = "right";
+ ctx.fillText(t.since ? `${w.stats.ticks - 300} ticks since it appeared` : `${w.stats.ticks} ticks`, width - 10, height - 10);
+ ctx.textAlign = "left";
+};
+
+const Panel = ({ note, qL, qR, sep = 26, height = 300, theory = GRAVITY_MAGNETISM, warm = 260, restart = 0, label, right = "destroyed against the vacuum's own rate", empty = false, since = false }: {
+ note: string; qL: 1 | -1 | 0; qR: 1 | -1 | 0; sep?: number; height?: number;
+ theory?: typeof GRAVITY; warm?: number; restart?: number; label: string; right?: string;
+ empty?: boolean;
+ /**
+ * Draw the change SINCE THE BODY APPEARED rather than the total.
+ *
+ * A total is dominated by the vacuum's own history — 57 destructions a cell before
+ * the body is even there — so a body's few per cent is invisible in it. Settling
+ * first and then differencing against that instant is what makes a panel about
+ * what a body DOES rather than about how long it has been running.
+ */
+ since?: boolean;
+}) =>
+ the excess against both images anyone has — the blue band is what a ray trace
+ says an instrument would see, the amber one is Kerr's own spread over spin, and
+ they are not the same kind of band
+
+
+ ({ frame: (s: Surface) => eht(s) })} />
+
+
+
;
+
+/** two opposite charges: the annihilation piles up between them */
+export const LatticeAttract = ({ height = 300 }: { height?: number } = {}) =>
+ {note}
+
+ {
+ let t: Two;
+ let acc = 0, warmed = 0;
+ const BUDGET = 12; // ms a frame may spend warming
+ // headless draws ONE frame and stops, so there the average has to be finished
+ // before it — see CANVAS.tsx
+ const HEADLESS = typeof IntersectionObserver === "undefined";
+ return {
+ start: () => {
+ t = make(qL, qR, sep, theory, empty, since ? warm : 0); warmed = since ? warm : 0;
+ // a `since` panel settled inside make(); its clock starts at the body
+ if (HEADLESS && !since) for (; warmed < warm; warmed++) t.w.tick();
+ if (HEADLESS && since) for (let i = 0; i < 24; i++) t.w.tick();
+ },
+ stop: () => { (t as unknown) = undefined; },
+ frame: (sur: Surface, dt: number) => {
+ if (warmed < warm) {
+ /*
+ * THE AVERAGE IS THE MEASUREMENT, so it has to exist — but building it
+ * inside `start()` froze the tab for a second or two per panel, on the
+ * main thread, as the reader scrolled past. It is spread over frames on a
+ * time budget instead, and the panel fills in while it is watched.
+ */
+ const t0 = performance.now();
+ while (warmed < warm && performance.now() - t0 < BUDGET) { t.w.tick(); warmed++; }
+ } else {
+ acc += Math.min(dt, 0.05);
+ while (acc > 1 / 20) { t.w.tick(); acc -= 1 / 20; }
+ /*
+ * AND THEN IT STARTS AGAIN, for the panel whose point is the EMERGENCE.
+ * A finished average is a picture of a result; watching the shadow climb
+ * out of the noise as √n is the thing being claimed, and it can only be
+ * seen from the beginning.
+ */
+ if (restart && t.w.stats.ticks > restart) { t = make(qL, qR, sep, theory, empty, since ? warm : 0); warmed = since ? warm : 0; }
+ }
+ paint(t, sur, label, right);
+ },
+ };
+ }} />
+
+
+
;
+
+/**
+ * ONE BODY IN THE VACUUM, AND HOW FAR ITS DEFICIT REACHES — which is nowhere.
+ *
+ * The same pure-gravity vacuum as above with one absorber dropped into it after it
+ * has settled, so that whatever appears is the body's doing. It is the article's own
+ * sentence — *the deficit expands at c̄* — put to the test at the rule's own rate.
+ *
+ * IT DOES NOT EXPAND. Measured against the far field, at every tick from 4 to 60
+ * without changing:
+ *
+ * r 4 6 9 13 18 24 30
+ * −16.7% 0.0% 0.0% 0.0% 0.0% 0.0% 0.0%
+ *
+ * Exactly the body's own surface, and exactly nothing beyond it. Not a weak signal
+ * under noise — the far field is uniform to the last digit, because the vacuum is
+ * perfectly regular. And it is the same at t = 60 as at t = 4, so nothing is on its
+ * way either.
+ *
+ * THE REASON IS THE UNCONDITIONAL SPLIT. Every point is refreshed completely every
+ * tick — split, annihilated, split again — so the medium has no memory from one tick
+ * to the next, and news cannot ride on a medium with no memory. This is not a limit
+ * on the SPEED of the deficit; there is no deficit out there travelling slowly. It is
+ * that a perfectly balanced breathing is unaffected by what happened next door.
+ *
+ * WHAT THIS PANEL IS FOR, then, is to say that plainly. The gravity arc's mechanism
+ * cannot be a shortfall propagating through the vacuum, because at the rule's own
+ * rate it does not propagate at all. What survives the correction is everything that
+ * does not depend on it — the metric read off annihilation counts, which is local to
+ * where the counting happens, and the results that rest on it.
+ */
+export const DeficitFront = ({ height = 300 }: { height?: number } = {}) =>
+ two bodies in the vacuum — the shortfall each leaves, and the push it makes: none
+
+ {
+ let w: World, bodies: Source[];
+ let sum: Float64Array, n = 0, acc = 0;
+ const HEADLESS = typeof IntersectionObserver === "undefined";
+
+ /** back to a fresh vacuum and an empty average, so the shadow climbs out again */
+ const restart = () => {
+ w = new World({
+ /*
+ * GRAVITY+MAGNETISM, because pure gravity has nothing to average.
+ *
+ * (G/2) is unconditional, so under gravity every point splits every tick
+ * and every one of those meetings is neutral and annihilates: one per
+ * edge, every tick, forever. Nothing survives, the destruction rate is
+ * uniform to the last digit, and the only structure anywhere is the rim
+ * of the body itself — which is what this panel drew, correctly and
+ * uselessly. Add polarity and half the meetings TURN instead: the vacuum
+ * persists at fill 0.5001, the derived ½, and a body's shortfall has
+ * something to be a shortfall IN. Measured, 41% deep at the body.
+ */
+ theory: GRAVITY_MAGNETISM, geometry: GEOM, N, seed: (Math.random() * 1e9) | 0,
+ boundary: "wrap",
+ });
+ bodies = [-GAP_CELLS / 2, GAP_CELLS / 2].map(dx =>
+ w.add({ at: [C + dx, C], radius: 2, emits: 0, absorbs: true, duty: 0 }));
+ sum = new Float64Array(w.backend.size());
+
+ n = 0;
+ };
+
+ /*
+ * WHAT IS COUNTED IS DESTRUCTION, NOT OCCUPANCY — and under gravity that is
+ * the only choice, because occupancy is identically zero.
+ *
+ * (G/2) is unconditional, so under gravity every point splits every tick and
+ * every one of those meetings is neutral and annihilates: measured on a 41²
+ * triangular lattice, 1,681 splits and 5,043 annihilations a tick against
+ * 5,043 edges — exactly one per edge, every tick, forever. Nothing SURVIVES,
+ * so `fill` is 0.0000 and a panel drawn from occupancy is black. It was.
+ *
+ * The vacuum is not idle, it is perfectly balanced: an enormous amount of work
+ * whose net is nothing. What a body does is break that balance where it sits,
+ * and the quantity that records it is how much space was destroyed — which is
+ * what this book says gravity IS.
+ */
+ /*
+ * OCCUPANCY, BECAUSE UNDER GRAVITY+MAGNETISM IT PERSISTS. Half of head-on
+ * meetings are alike and TURN rather than annihilate, so the vacuum holds at
+ * fill 0.5001 and "how many are missing" is a question with an answer. Under
+ * pure gravity it is not: nothing survives a tick, occupancy is identically
+ * zero, and this panel was black — which is why it runs g+m.
+ */
+ const occ = (k: number) => {
+ let c = 0;
+ for (let d = 0; d < GEOM.DEG; d++) if (w.backend.active(k, d)) c++;
+ return c / GEOM.DEG;
+ };
+ const step = () => {
+ w.tick();
+ n++;
+ w.backend.forEachLocal(k => { sum[k] += occ(k); });
+ };
+
+ return {
+ start: () => { restart(); if (HEADLESS) for (let i = 0; i < 2000; i++) step(); },
+ stop: () => { (w as unknown) = undefined; sum = new Float64Array(0); },
+ frame: (sur: Surface, dt: number) => {
+ acc += dt;
+ /*
+ * IT RUNS TO 2400 RATHER THAN THE ARCHIVE'S 900, because the arrow is a
+ * measurement and at 900 it is not one. Measured over eight seeds, the
+ * left body's differential push comes to +0.008 ± 0.028 at 560 ticks —
+ * the sign is a coin flip, [-+-+-+++] — and +0.023 ± 0.019 at 2000, where
+ * seven of eight are positive and the mean is 3.4σ from zero. So the
+ * arrow is drawn only once there is something to draw.
+ */
+ while (acc > 1 / 90) { acc -= 1 / 90; if (n >= 2400) restart(); else step(); }
+
+ const { ctx, width, height: H } = sur;
+ ctx.clearRect(0, 0, width, H);
+ ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, H);
+
+ const TOP = 20, BOT = 18, GAP = 10;
+ const cw = (width - GAP) / 2;
+ const side = Math.min(cw, H - TOP - BOT);
+ const pz = side / (2 * VIEW + 1);
+ const top = TOP + Math.max(0, (H - TOP - BOT - side) / 2);
+
+ /*
+ * THE LEVEL FAR FROM EITHER BODY, which is the zero the right half is drawn
+ * against. A body's shadow is a DIFFERENCE from what the vacuum does
+ * anyway, so the vacuum's own level has to be measured rather than assumed
+ * — it moves with occupancy, geometry and rate.
+ */
+ let bg = 0, bn = 0;
+ w.backend.forEachLocal(k => {
+ if (w.isSource(k) || !n) return;
+ const p = px(w, k);
+ if (Math.hypot(p[0] - (C - GAP_CELLS / 2), p[1] - C) < 34) return;
+ if (Math.hypot(p[0] - (C + GAP_CELLS / 2), p[1] - C) < 34) return;
+ bg += sum[k] / n; bn++;
+ });
+ bg = bn ? bg / bn : 0;
+
+ /*
+ * THE SHORTFALL, SMOOTHED BEFORE IT IS LOGGED — without this the log makes
+ * things worse rather than better.
+ *
+ * Per cell the mean occupancy still carries shot noise about the size of
+ * the signal at r = 8, which is 1.8% of the far field. A log scale lifts
+ * small numbers, so it lifts that noise exactly as faithfully as it lifts
+ * the halo, and the panel comes out an even orange speckle with two bright
+ * dots in it. Averaging over a neighbourhood divides the noise by the
+ * number of cells in the box and leaves the structure alone — the same √n
+ * the time average buys — and only then is the log honest. Nothing is
+ * scaled up; the noise is taken down.
+ */
+ /*
+ * A ROUND KERNEL, because a square one prints its own shape. Box-averaged,
+ * each halo came out with straight edges and corners — the window showing
+ * through as structure, which is the one thing a smoothing window must not
+ * do. A disc has no orientation to leak.
+ *
+ * AND THE WIDTH IS DOING VISIBLE WORK, which has to be said rather than
+ * left for someone to find. Measured raw, with no smoothing at all, the
+ * shortfall around a body of radius 2 is:
+ *
+ * r 3 4 5 6 12 30
+ * 0.2525 0.0951 0.0002 0.0002 −0.0007 −0.0006
+ *
+ * Three orders of magnitude across two cells. The field itself is a RIM,
+ * not a halo — at p = 1 the vacuum is refreshed completely every tick, so
+ * nothing carries the shadow outward and there is no tail to reveal. The
+ * gradient this panel shows is that rim convolved with a disc of radius
+ * `B`, which is a legitimate way to see where a small feature sits and is
+ * NOT a picture of the field falling off gently. Read the width of the
+ * glow as the width of the filter.
+ */
+ const B = 7;
+ const KER: number[][] = [];
+ for (let i = -B; i <= B; i++) for (let j = -B; j <= B; j++)
+ if (i * i + j * j <= B * B) KER.push([i, j]);
+ const WIN = KER.length;
+ const fld = new Float64Array(N * N).fill(NaN);
+ w.backend.forEachLocal(k => {
+ const q = px(w, k);
+ fld[Math.round(q[0]) * N + Math.round(q[1])] = sum[k] / Math.max(n, 1);
+ });
+ const smooth = new Float64Array(N * N).fill(NaN);
+ for (let x = B; x < N - B; x++) for (let y = B; y < N - B; y++) {
+ let acc2 = 0, m = 0;
+ for (const [i, j] of KER) {
+ const v2 = fld[(x + i) * N + (y + j)];
+ if (!Number.isNaN(v2)) { acc2 += v2; m++; }
+ }
+ if (m >= WIN * 0.5) smooth[x * N + y] = acc2 / m;
+ }
+
+ for (const col of [0, 1]) {
+ const cx = (col === 0 ? cw / 2 : cw + GAP + cw / 2), cy = top + side / 2;
+ w.backend.forEachLocal(k => {
+ const p = px(w, k);
+ const x = p[0] - C, y = p[1] - C;
+ if (Math.abs(x) > VIEW || Math.abs(y) > VIEW) return;
+ // left: what is there. right: how much is MISSING.
+ /*
+ * THE FAR FIELD'S OWN LEVEL SETS BOTH SCALES, rather than a constant
+ * measured once and left behind. Left: this tick's destructions
+ * against the mean rate. Right: how far BELOW that mean the running
+ * average sits, full ink at a fifth of it. A hard-coded divisor was
+ * right for one creation rate and silently wrong at the rule's own.
+ */
+ /*
+ * THE SHORTFALL ON A LOG SCALE, because it is a power law and a power
+ * law inked linearly is a dot. Measured on this arrangement, the
+ * shortfall is 41% of the far field AT the body and 1.8% by r = 8 —
+ * a factor of twenty across eight cells — so on a linear scale
+ * everything past the rim sits under the first shade and the panel
+ * reads as two circles on black. It did. Each halving now gets the
+ * same number of shades.
+ */
+ const rate = smooth[Math.round(p[0]) * N + Math.round(p[1])];
+ const d = Number.isNaN(rate) ? 0 : Math.max(0, bg - rate) / Math.max(bg, 1e-9);
+ // low enough that the smoothed tail is still inked rather than clipped
+ const FLOOR = 0.0006;
+ const v = col === 0
+ ? occ(k)
+ : Math.log(1 + d / FLOOR) / Math.log(1 + 1 / FLOOR);
+ if (v <= 0.004) return;
+ ctx.globalAlpha = Math.min(1, v);
+ ctx.fillStyle = col === 0 ? PLUS : MINUS;
+ ctx.fillRect(cx + x * pz - pz / 2, cy + y * pz - pz / 2, pz + 0.6, pz + 0.6);
+ });
+ ctx.globalAlpha = 1;
+
+ for (const b of bodies) {
+ let bx = 0, by = 0;
+ for (const k of b.locals) { const q = px(w, k); bx += q[0]; by += q[1]; }
+ bx = bx / b.locals.length - C; by = by / b.locals.length - C;
+ ctx.strokeStyle = SEEN; ctx.lineWidth = 1.2;
+ ctx.beginPath();
+ ctx.arc(cx + bx * pz, cy + by * pz, 2.8 * pz, 0, 2 * Math.PI);
+ ctx.stroke();
+
+ if (col === 1) { // the measured push, on each body
+ /*
+ * THE MUTUAL FORCE IS THE DIFFERENTIAL PART, and taking it is not a
+ * cosmetic choice — it is the same paired differencing every force
+ * measurement in this project uses.
+ *
+ * Both bodies read a COMMON offset: measured, −0.064 and −0.111 per
+ * tick in x, so both appear pushed the same way. That common part is
+ * what a body of this shape feels in a box of this size anyway —
+ * lattice anisotropy and the wrap — and it is identical for both, so
+ * it cannot be what they do to EACH OTHER. Subtracting the mean
+ * leaves +0.0235 and −0.0235: equal, opposite, and pointing at each
+ * other, which is the claim the panel is making.
+ */
+ const mx = bodies.reduce((a, o) => a + (o.absorbed[0] ?? 0), 0) / bodies.length;
+ const my = bodies.reduce((a, o) => a + (o.absorbed[1] ?? 0), 0) / bodies.length;
+ const spread = Math.max(1e-9, Math.abs(
+ (bodies[1].absorbed[0] ?? 0) - (bodies[0].absorbed[0] ?? 0)) / 2);
+ const sc = 26 / spread;
+ const fx = ((b.absorbed[0] ?? 0) - mx) * sc, fy = ((b.absorbed[1] ?? 0) - my) * sc;
+ if (n < 1200 || Math.hypot(fx, fy) < 2) continue; // not resolved yet
+ const x0 = cx + bx * pz, y0 = cy + by * pz;
+ ctx.strokeStyle = GOOD; ctx.lineWidth = 1.6;
+ ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x0 + fx, y0 + fy); ctx.stroke();
+ const ang = Math.atan2(fy, fx);
+ ctx.beginPath();
+ ctx.moveTo(x0 + fx, y0 + fy);
+ ctx.lineTo(x0 + fx - 5 * Math.cos(ang - 0.4), y0 + fy - 5 * Math.sin(ang - 0.4));
+ ctx.moveTo(x0 + fx, y0 + fy);
+ ctx.lineTo(x0 + fx - 5 * Math.cos(ang + 0.4), y0 + fy - 5 * Math.sin(ang + 0.4));
+ ctx.stroke();
+ }
+ }
+ }
+
+ ctx.font = "11px ui-monospace, monospace";
+ ctx.textAlign = "center";
+ ctx.fillStyle = INK;
+ ctx.fillText("one tick — every edge annihilates, uniformly", cw / 2, 13);
+ ctx.fillText(`averaged over ${n} ticks`, cw + GAP + cw / 2, 13);
+
+ ctx.font = "10px ui-monospace, monospace";
+ ctx.fillStyle = FAINT;
+ const mx0 = bodies.reduce((a, o) => a + (o.absorbed[0] ?? 0), 0) / bodies.length;
+ const push = bodies.map(b =>
+ (((b.absorbed[0] ?? 0) - mx0) / Math.max(n, 1)).toFixed(3));
+ /*
+ * AND THE PUSH IS EXACTLY ZERO, which is the panel's actual result and is
+ * printed rather than hidden. At the rule's own creation rate the vacuum
+ * is refreshed completely every tick, so what arrives at a body is
+ * isotropic no matter what is beside it: measured over 600 ticks in
+ * gravity+magnetism, each body's net absorbed momentum along the line
+ * joining them is 0.0000. Two absorbers do not attract here.
+ */
+ ctx.fillText(`push on each body ${push[0]} and ${push[1]}` +
+ (Number(push[0]) === 0 && Number(push[1]) === 0
+ ? " — exactly zero: nothing reaches across"
+ : " — equal and opposite"),
+ width / 2, H - 5);
+ ctx.textAlign = "left";
+ ctx.fillText("left: the charges themselves.", 8, H - 5);
+ ctx.textAlign = "right";
+ ctx.fillText("right: how many are MISSING.", width - 8, H - 5);
+ ctx.textAlign = "left";
+ },
+ };
+ }} />
+
+
+
;
diff --git a/orbitmines.com/src/routes/Physics/visuals/STEP.tsx b/orbitmines.com/src/routes/Physics/visuals/STEP.tsx
new file mode 100644
index 00000000..07f9275e
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics/visuals/STEP.tsx
@@ -0,0 +1,175 @@
+/**
+ * DID THE STEP APPEAR? — the figure the whole lattice-versus-MOND question comes to.
+ *
+ * Two panels, one per predicted discontinuity, each stacked on its own boundary. Only
+ * galaxies with measured points on BOTH sides are in them, each with its own offset
+ * removed, because a distance error moves a whole galaxy together and would otherwise
+ * be free to manufacture a jump. So what is plotted is a comparison inside galaxies,
+ * which is the only comparison a step can survive.
+ *
+ * The amber staircase is what the lattice says has to be there — position from the
+ * direction cosines, size from the projection over 26 exits, nothing fitted. The blue
+ * one is what the data give. The white points are the measurement, binned.
+ *
+ * AND THE ANSWER IS THAT THEY ARE THE SAME HEIGHT AS THE ERROR BARS, which is why this
+ * figure is worth drawing rather than a sentence: a reader can see at once that the
+ * prediction is not excluded, not detected, and that the two are the same statement
+ * here. `cosmology/lattice-step` carries the numbers.
+ */
+
+import { CanvasView, Surface } from "./CANVAS";
+import { entryOf } from "./FIGURES";
+import { STEPS, residuals } from "../STEP";
+import { GALAXIES } from "../SPARC";
+
+const BACK = "#08090d", FAINT = "#5a5f6e", GRID = "rgba(120,127,148,0.13)";
+const SEEN = "#eef0f5", MODEL = "#4aa8eb", PRED = "#d4b48b";
+
+const W = 0.5, NBIN = 10;
+
+/** the straddling galaxies inside one window, each flattened by its own mean */
+const stacked = (xc: number) => {
+ const pts = residuals();
+ const byGal = new Map
+ the same four spokes in the same disc, each clocked by its own outermost star —
+ Newton left, the transport law right. Both wind; what differs is how fast the
+ inside turns relative to the outside, which is the flat curve seen as a shape
+
+
+
+
+ draw(false, "Newton")} />
+
+
+ draw(true, "the transport law")} />
+
+
+
;
diff --git a/orbitmines.com/src/routes/profiles/fadi-shawki/bibliography.ts b/orbitmines.com/src/routes/profiles/fadi-shawki/bibliography.ts
new file mode 100644
index 00000000..ffc2dbe9
--- /dev/null
+++ b/orbitmines.com/src/routes/profiles/fadi-shawki/bibliography.ts
@@ -0,0 +1,4789 @@
+/**
+ * Everything read, watched, worked at and attended — the bibliography the
+ * articles cite from.
+ *
+ * It was in `fadi_shawki.ts` next to the profile, and that turned out to be
+ * expensive in a way that had nothing to do with either of them. The profile is
+ * what `references.tsx` names in order to put an author on a paper, so every
+ * paper on the site imported this module; the profile's `content` pointed at a
+ * dozen entries in here, which kept the whole four thousand line literal alive;
+ * and so every article shipped the complete bibliography in order to print one
+ * name under its title.
+ *
+ * Split, the profile is a few lines and this is imported by the three places
+ * that actually cite from it. Nothing in here changed in the move.
+ */
+import ORGANIZATIONS, {Content, ExternalProfile, TProfile, Viewed} from '../../../lib/organizations/ORGANIZATIONS';
+
+// TODO: Just a crude initi\al setup while the interface is not yet workable
+
+const string = `
+- [An Infinity of Worlds: Cosmic Inflation and the Beginning of the Universe (2022)](https://books.google.nl/books/about/An_Infinity_of_Worlds.html?id=G3aMEAAAQBAJ&source=kp_book_description&redir_esc=y) ; *Will Kinney*
+
+- :youtube: :lex_fridman_podcast: [State of AI in 2026: LLMs, Coding, Scaling Laws, China, Agents, GPUs, AGI | #490 (2026)](https://www.youtube.com/watch?v=EV7WhVT270Q&t=2s) ; *Nathan Lambert, Sebastian Raschka, Lex Fridman*
+- :youtube: :lex_fridman_podcast: [OpenClaw: The Viral AI Agent that Broke the Internet - Peter Steinberger | #491 (2026)](https://www.youtube.com/watch?v=YFjfBk8HI5o&t=2s) ; *Peter Steinberger, Lex Fridman*
+- :youtube: :lex_fridman_podcast: [Jeff Kaplan: World of Warcraft, Overwatch, Blizzard, and Future of Gaming | #493 (2026)](https://www.youtube.com/watch?v=H9rF1CSSh-w&t=8566s&pp=0gcJCd4KAYcqIYzv) ; *Jeff Kaplan, Lex Fridman*
+- :youtube: :lex_fridman_podcast: [Jensen Huang: NVIDIA - The $4 Trillion Company & the AI Revolution | #494 (2026)](https://www.youtube.com/watch?v=vif8NQcjVf0&t=1s) ; *Jensen Huang, Lex Fridman*
+- :youtube: :lex_fridman_podcast: [Vikings, Ragnar, Berserkers, Valhalla & the Warriors of the Viking Age | #495 (2026)](https://www.youtube.com/watch?v=iKx3gAODybU) ; *Lars Brownworth, Lex Fridman*
+- :youtube: :cool_worlds_podcast: [#31 Joshua Winn - Exoplanet New Discoveries, History and Future (2026)](https://www.youtube.com/watch?v=ISZHVwY5YjE) ; *Joshua Winn, David Kipping*
+- :youtube: :cool_worlds_podcast: [#32 Chris Lintott - Technosignatures, Citizen Science, Scicomm (2026)](https://www.youtube.com/watch?v=qI3DAXM0-do) ; *Chris Lintott, David Kipping*
+- :youtube: :topos_institute: [Dan Ghica: Designing and developing an industrial-strength programming language (2026)](https://www.youtube.com/watch?v=oFGc4hGJRJQ) ; *Dan Ghica*
+- :youtube: [Where We’re Going, We Don’t Need Rows: Columnar Data Connectivity with Apache Arrow ADBC (2025)](https://www.youtube.com/watch?v=TjlmNGNx77E) ; *Ian Cook*
+- :youtube: [Vortex: LLVM for File Formats (2025)](https://www.youtube.com/watch?v=zyn_T5uragA) ; *Will Manning*
+- :youtube: [DuckLake: Learning from Cloud Data Warehouses to Build a Robust “Lakehouse” (2025)](https://www.youtube.com/watch?v=z2GhznqtIz0) ; *Jordan Tigani*
+- :youtube: [An Extremely Technical Overview of How Apache Iceberg Planning Actually Works (2025)](https://www.youtube.com/watch?v=kJaD0WuQ1Bg) ; *Russell Spitzer*
+`
+
+export const REFERENCES = {
+ THE_METAVERSE_BUILDING_THE_SPATIAL_INTERNET:
+ the two discontinuities the lattice requires, looked for inside the galaxies that
+ straddle them — the prediction is the same height as the error bars
+
+
+ ({ frame: (s: Surface) => panel(s) })} />
+
+