e64 — stepping f

The 64-byte enwik9 prefix, settled one time step at a time under live settling rules. A time step in f is one application of the total (visible) pattern — the part of P inside the window of indeterminacy — and it is built from pattern applications, three per unclamped position: forward k=1, backward k=1, and the k=2 token. Spec: #p8v2_e64_viewer_goal_20260805; prerequisites: #hutter_e64_viewer_prereq_20260805.

THIS IS THE GENERATION 2 RECORD, AND IT IS FROZEN. Generation 3 answered the questions this page was built to ask, and its instrument is /hutter/pprog/p8v2-gen3-e64/ — three new axis-A rules that set a pattern's fall-off from its own support, the panel that IS f, and the LATD expansion wired to the query layer. This page is not rebuilt to follow it: a superseded page is frozen so it can still be compared with, which the generation-1 page cannot be, because it was rebuilt in place. See #viz_standard, "Versioning a viewer".

NOTHING ON THIS PAGE IS A RESULT. No picks, no ranking, no chart point, no compression number. Ten variants were run and are marked RUN; every other setting is the viewer's own and is marked not a measurement.

This instrument runs f in your browser and needs JavaScript. The data it uses is published beside it: the ten models under models/ and the dumps under gen2-pos/.

What the conformance check does and does not pin

What a pattern application is

One LPP's contribution to one position, computed from one neighbouring source position. Three per unclamped position per time step: forward k=1 from the position to the left, backward k=1 from the right, and the k=2 token from the two to the left through the AND gate. The step bar counts them; it is the same count the compressor reports as its settling cost.

Each entry of an application is min(w_p, w_s) — the pattern's own weight capped by the source's activation. That is the inner min of the UM's max-min forward pass, f_p(t)_j = max_i min(t_i, p_ij), with the source restricted to its argmax event by the admitted optimization (exact when the source is absolute, an approximation elsewhere; the detail pane unfolds it by naming the source event). Under A1 the forward and backward applications are then combined with the outer max. So the machinery here is not new: it is the forward pass written out longhand.

Two places that departure matters, and both are visible on this page:

A k=2 token application ASSIGNS rather than maxing. Where it fires it overwrites the position's state instead of joining the max. #f-p8 argues that is correct because k=2 is a subset of k=1 and the two are fully correlated. It is also exactly why axis D can remove nothing: the settled argmax at a candidate position is then just the causal composite prediction, which is wrong there by construction. That is Q4.
A2 and A3 leave max-min altogether. They replace the outer max with LSA addition — A2 against a decay of 2 units per step, A3 with renormalisation to constant sum. That is a different f, not bookkeeping inside the same one.

The operations, in ordinary arithmetic

Every weight on this page is a log support: the value v stands for a magnitude of about 2^v, which is why 255 is an absolute rule and 1 is a thing seen once. That is the whole reason the arithmetic below is not the arithmetic it looks like. Nothing on this page names an operation without a row here.

operation	in ordinary arithmetic	saturates	draws from the entropy stream
min(w_p, w_s)	the smaller of the two. It is the whole of a pattern application's entry: the pattern's own weight, capped by how strongly its source is active.	no	no
the outer max	the larger of the two. Two applications arriving at one position keep the stronger; neither reinforces the other. This is what A2 and A3 replace.	no	no
LSA addition	adding the magnitudes, not the values. Equal values give one more than either — 2^v+2^v is 2^v+1. Values `d` apart give the larger one, except that with probability 2^−d it rounds up by one instead, which is how the fraction that will not fit in a byte is carried.	at 255	yes — one draw per unequal pair
LSA subtraction	the difference of the two values, which is the ratio of the magnitudes. Never negative: below zero it is zero, and a zero is silence, not impossibility.	at 0	no
the LSA total of a position	LSA addition folded across all 256 entries from index 0 upward, giving the magnitude of the whole vector. A3 uses it to find how far the position overshoots a constant sum.	no — A3 needs the overshoot, so the fold is left to run past 255	yes — up to 255 draws
the ceiling of the base-2 logarithm	how many bits it takes to name one of `n` things: 0 for one, 1 for two, 2 for three or four, 3 for five to eight. B1 charges it to every predecessor when it divides a backward weight over the set that leads to the same byte.	no	no
w_p − (255 − w_s)	the rejected application rule, kept as a control. It charges the source's distance from certainty against the pattern, so anything short of an absolute source annihilates the application. Drive it and watch the window collapse.	at 0	no

The two rows that draw from the entropy stream are the reason a variant can be uncheckable: the stream is shared with learning, so by the time settling starts it sits wherever learning left it, and a recomputation cannot land on the same draws. Which variants that costs is counted above, under the conformance check, rather than asserted here. Implementation: #pp_lsa, in ../cmpr-src.

How to read it

byte	the sample. Non-printable bytes are shown as `·`; the detail pane gives the value.
argmax	the settled argmax at this time step — the largest entry of the position's LSA vector, ties to the smaller index. Blue = clamped (the trace records it, so it is held at 255 on its own event and never updates). Green = agrees with the byte, red = disagrees.
w1	the weight of that entry. Clamped positions read 255.
chg	shaded where this time step changed the position's argmax. When the whole row is clear, the window's argmax sequence has stopped changing — that step is `conv`.

The controls

control	what it changes
A1 A2 A3	The update rule — this is f. A1 assignment: the longest k that fires assigns. A2 LSA addition against decay of 2 units per step. A3 addition with renormalisation to constant sum 255. Applied live.
B1 B2	The backward k=1 application. B1 reconstructs it from the forward argmax table by normalising over the predecessor set, each predecessor paying the ceiling of the base-2 logarithm of how many there are. B2 reads a stored 65536-byte LPP. Applied live — but only one model carries that LPP, so B2 is refused where it would be borrowed from a model with a different learned k=1.
C1 C2	The AND gate at partial activation. C1 `min(w_a,w_b)`. C2 sums and thresholds at 128, activation `sum−128` capped at 255. Applied live.
min / sub	The application rule (Q5). `min(w_p,w_s)` is what every run used. `w_p−(255−w_s)` is the form that was tried and rejected. It is implemented in no variant, so there is no dump of it and every frame under it is unverified, including the endpoint. The agreement readout under it is the viewer's own computation, live from the model on screen, not a quoted measurement. Set it on the baseline and step: every non-absolute application dies one hop from a clamped position and the window collapses.
D E F	Which learned model is loaded. Unlike A/B/C these are not settling rules: sparsification, replay and pruning change what was learned and recorded, so each selects a different model file rather than a different computation. Only single-axis combinations were run, so setting two of them away from the baseline has no model and is refused.
steps	How far f runs (Q7). An application travels one position per time step, so stopping short of W leaves the far end of the window on its initial state. Drive it on the baseline and the agreement readout gives 11, 12, 14, 27, 49, 62, 64 at 1, 2, 4, 8, 16, 24 and 32 steps: the window is fully settled by 32, and stopping at 24 costs two positions. The step count is what these numbers measure; the application rule is a separate control, and under `w_p−(255−w_s)` agreement is 10 of 64 at every step count. Both are reproducible here.

The axes, and how to read a variant

What e64 shows, by axis

Diagnostics from gen2.tsv. D and F genuinely coincide with the baseline at 64 bytes — every context is kept, so a prune rule has nothing to prune, and the settled state is never consulted by D1's causal pass. They keep their controls anyway: a control whose alternatives coincide at this sample is still a control, and it says so here rather than being omitted.

The settling columns, defined

And the measured e64 values of those columns, from gen2.tsv:

What is still open

ONE PATTERN, TWO STRENGTHS. The k=1 section of the model is 256 bytes of argmax and stores no weight at all, so anything that reads it has to supply one, and the two things that read it supply opposite ends of the scale. The query layer reports every k=1 pattern at 1 — all 256 of them, in all ten models. The settling shell applies them at 255: under B1 a forward application is min(255, w_s), which is the source's activation passed through unattenuated. On a log-support scale those are not near-misses. 1 says seen once; 255 says an absolute rule.

It shows up inside axis B as well, where the axis says only that B1 reconstructs the backward direction and B2 stores it. The stored 65536-byte LPP carries 41 entries at strength 1 and 6 at 2 — the same support the query layer reports — so the same pattern is absolute under B1 and support-1 under B2. That is a difference in what the pattern says, not in how it was obtained.

This page does not resolve it: the k=1 strength is ../cmpr-src's to fix, in whichever direction it decides. It reports both, in the detail pane, on every forward application, rather than quietly printing the one that agrees with what the engine did. The k=2 token strengths have no such gap: the model stores them, the query layer reports them, and the shell applies them, and all three agree.

THERE IS NO k=0 BACKGROUND. An unclamped position initialises to 256 zeros, and under B1 a byte with no predecessor sends no backward application at all rather than falling back to a base rate. The model file carries no byte-frequency section: the k=1 argmax table starts at offset 48 and every offset past the header sits 256 lower than a model built before 2026-08-06, which the builder rejects on the size identity rather than misreading its argmax table as a background.

TWO AXES ARE OPEN IN A WAY THE MARKS ON THIS PAGE CANNOT SETTLE. D is the only axis that moves the rate, and neither of its alternatives round-trips above 64 bytes — a real trace reduction that is not yet a real compression. C2 is byte-identical to the baseline at every sample that can be run, because the AND gate never binds while the learned k=2 weights are 1 or 2. Both are measured in the generation 2 report, which is published beside this page rather than summarised on it.

Sources

models/p8v2/enwik9/64/	the retained models; k=1 argmax table at offset 48, backward LPP at 304, then four bytes per token rule. No k=0 section
gen2-pos/	the recorded endpoints the conformance check compares against
gen2.tsv	measured facts, including the e64 settling diagnostics above
axes.json	the axes, their alternatives and the definitions on this page — the page reads it, it is not copied here
the generation 2 report	what these runs say, and the picks it asks for
p8v2-words.md	the fixture; § Axis A is the settling shell this page implements
build-p8v2-e64	rebuilds this page. Runs no compression
#pprog_p8v2_gen2_goal_20260806	the goal generation 2 was run against, and what it reserved each variant id for
p8v2-gen1/	the generation panels: every variant of a generation over the same input positions. Generation 1's runs are comparable with these, having been re-run post-k=0
#hutter_e64_viewer_prereq_20260805	the prerequisites this was built against
#p8v2_e64_viewer_goal_20260805	the goal this was built from
#hutter_publication_handoff	the division of labour, and what is not a result
#variant_protocol	why there is no winner here

Published under #viz_standard. Self-contained: no external stylesheet, no script, no font, no image, nothing fetched. Data symlinked from ../cmpr-src/tests/pprog/; page regenerated by docs/pprog/build-p8v2-e64, never hand-edited. The blocks are the authority.