NO PUBLIC MATH // PERPETUAL // SYSTEM BY MODEST

no public math is a perpetual, self-verifying visualizer of arithmetic, conducted by the Ethereum network. Every ~12 seconds, Ethereum commits a new block. The piece takes each block’s hash, carves a multiplication problem out of it, and performs that multiplication on screen — by hand, in public, showing every step — then rests on the answer until the next block arrives and sets the next problem. It never repeats, because the chain never repeats.

The work runs as a single self-contained HTML file. No dependencies, no wallet, no backend. A browser and a public RPC endpoint are the entire stack.

The thesis it stages: multiplication is expensive; addition is honest. This is not a metaphor here. Ethereum’s own fee schedule prices a MUL opcode at 5 gas and an ADD at 3 — the trade the piece performs, decomposing one multiplication into its constituent additions, is priced by the network itself, and the piece prints the receipt.

Each block is solved in five acts, narrated by a caption strip at the bottom of the canvas that states, with the live numbers, exactly what the machine is doing.

The hold. The solved equation rests on screen until the next block arrives. Captions rotate through the answer, the EVM gas receipt, and WAITING FOR BLOCK #N+1. The header clock reads T+ss.ss / 12s SLOT in real seconds — when it passes 12 without a cut, you are watching a missed slot on mainnet.

The audit lens. A single magnifier continuously tracks wherever the computation is live — the row being written, the digit being summed, the carry in flight — and re-presents it 2× in a docked inset with a leader line, labeled with what it shows.

Interference. Several times per block, a hostile visual system — displacement shreds, stair tears, inversion strikes, a strobing lattice of × glyphs — attacks the frame, then is cut. The audit lens samples the clean render buffer underneath, so during interference the inset shows the uncorrupted computation, labeled AUDIT // INTERFERENCE. The audit cannot be jammed. Blocks with gas utilization below 25% may render with no interference at all — the rare CLEAN SIGNAL trait.

The piece polls eth_getBlockByNumber(["latest", false]) every 4 seconds against a fallback chain of public JSON-RPC endpoints (LlamaRPC → PublicNode → Cloudflare). No API keys; failures cascade to the next endpoint, and total unreachability produces a labeled retry state, never a broken render.

From each block it reads: number, hash, gasUsed, gasLimit, baseFeePerGas, and the transaction count.

Operands are sliced directly from the block hash:

The full hash also seeds a deterministic PRNG (xmur3 string hash → sfc32, with a 16-round warm-up to eliminate early-output bias) that derives every other property: palette, act tempo, ground polarity scheme, staging variants, panel mosaic, interference schedule, weave moduli.

Same block, same artwork, forever. Block hashes are immutable, so every block in Ethereum’s history is a fixed, reproducible edition of the piece.

The state of the network is mapped structurally, not decoratively:

The chain strip above the canvas states these mappings live — ◆ ETHEREUM MAINNET // PERPETUAL // SOLVING BLOCK #N // GAS 54% → INTERFERENCE // 183 TXS → PANELS // 11.2 GWEI // NEXT #N+1 QUEUED — flashing on each new block.

All motion is downstream of a real computation performed at derivation time:

Partial products. For each digit d of B (least significant first): row = A × d, with shift recorded.

Grand column sum. For each output column, the contributing digits across shifted rows are summed with carry-in; the written digit is sum mod 10, carry-out is ⌊sum / 10⌋. The column digits reconstruct the product exactly (verified in test).

Adder tree. Shifted row values are summed pairwise per level until one value remains; its root equals A × B (verified).

Checksum. Digit sum and digital root of the product.

Gas accounting. The engine counts every digit-addition the choreography performs and prices the run in the EVM fee schedule:

The captions state both — the transparency premium, in the network’s own units. Every caption equation is generated from this data, so nothing narrated on screen can be wrong.

1080×1080 canvas, rendered to an offscreen buffer and composited — which is what allows the interference layer to attack the visible frame while the audit lens samples the clean buffer beneath.

Typography. A custom 3×5-cell block digit font (0–9, ×, +, =) drawn as geometry, no font files; glyphs reveal cell-by-cell, right-to-left, as if typed.

Residue weave. Background texture from (i·j) mod m — literally a multiplication table — with the modulus stepping through a seeded sequence and a traveling accent sweep.

Palette. Each block draws a primary and secondary from five Lamborghini factory colors, plus a constant acid green:

Staging variants per block. Act tempo distribution, six ground-polarity schemes, three worksheet anchors, seeded row-reveal order, triptych vs mega-column carry act, tally-rain vs typeset finale, panel mosaic layout. Structural variety is seeded, not cosmetic.

Interference. Displacement and inversion effects quantized to hash steps — datamosh cadence, not tweened — with onset inversion flash and frame shake, enveloped in and hard-cut out.

The full choreography is authored as a 28-second score. In perpetual mode it plays at 2.67× (10.5s) to fit inside Ethereum’s fixed 12-second slot, then holds. A new block is adopted only at the solve boundary — every problem completes with dignity; the piece never abandons an equation mid-carry.

All animation is a pure function of (block hash, time): there is no accumulated state, so the piece can run indefinitely without drift, and any moment of any block is exactly reproducible.

Built-in recording uses MediaRecorder with MP4-first codec negotiation (H.264 avc1 on Safari / Chrome / Edge; VP9 WebM fallback on Firefox). The stop condition is animation-clocked, not wall-clocked: the capture always contains one full solve plus a held tail on the answer, regardless of render stutter.

The derivation function is consensus-critical. Once any block-to-artwork mapping is published as canonical, the renderer is frozen: any change to derive() — including bugfixes — re-authors every historical edition. Fixes ship as versioned renderers, never edits.