## p8v2 words This file builds off of, simplifies, and obsoletes p9-factored-words as well as p7 and the original p8. We treat the previous p8 as a false start, so in the externally maintained progress chart, this data point will connect to p7 as the ancestor, not to p8v1 (which was a series at different DSS scales). What is P8? In P7 we added a Markov model to the memory chain and the top-level joint event memory. This took the compression factor k from 0 to about 42, r=.656, so 656MB on enwik9. Now we describe the addition of P8 and why it can only help performance. First, we are already encoding against the Markov model the gaps between surprise events, as well as the surprise bytes themselves. The gaps were encoded in some unary encoding, after subtracting 1, which would be optimal if the gaps were 50% length 1, 25% length 2, and so on, always length N being encoded as N+1 bits, and occurring with p = 1/2^N. This is not exactly optimal but it's something we decided not to worry about yet. The highest possible cost of the unary gap encoding is 1 bit per byte, which is significant, but easy to optimize away later. Specifically, once the average gap size gets to be ~8 bytes, then we will be spending as much on the gap encoding as we do on the surprising bytes themselves; at this point it will be an obvious win to entropy-code the gaps themselves, and furthermore to improve the uniformity in the gaps, which we have various ways of doing. However, we will keep the unary encoding as it is easy to entropy code later on (and in fact the integration of all the low-order bits of a Godel encoding may solve things for us). Additionally, we have to prepare to combine information sources at different scales, so it makes sense that we would start that work now, at the first point where we have two meaningful levels of abstraction, i.e. two factorings of the input. The biggest change from the failed p8v1 is that we do not encode words at all in the memory trace (i.e. the compressed data file). Rather, we continue to encode only the surprising bytes (that is, those which are not the most likely under the model), and their gaps. The entire compression procedure now differs from p7 in that we have a word model above the first-order Markov model over letters. The only compression improvement comes from this word model, which affects the letter probabilities, thereby making fewer of the actual byte events part of the memory trace because fewer of them are surprising. The compression procedure is that we fill the memory chain, as we currently do in the p7 model when decoding. We simplified the word model into a token model, which does not distinguish between word and non-word chars, but is a general prediction of the next byte from a preceding byte sequence. The information content of the word model is then a lexicon or token set (including arbitrary byte sequences that are not actual words) and for each element of the set, a log support value, accumulated via LSA. The word model learns word events automatically, in a merge-like manner, and online. It is only online at compression time, since decompression requires the same model, which we must serialize in the compressed data file. The recall process, previously: the surprise events are filled in, and then the Markov-1 model is applied placewise to the right from each suprise event and stopping at the next surprise event. However, now it is possible for the Markov-1 byte model to be incorrect, because we also have the word model, so we need a recall process that integrates both. Let's sketch the word model, which is a LPP or generalized function on byte sequences and word events. Take an arbitrary maximal word length, say 16 bytes at first. This gives us a 16-length memory chain, with 256 * 16 atomic events. Then we have a word model, which should recognize words in arbitrary positions (i.e. arbitrary offsets mod 16). The word model both predicts/recognizes word length, and the word event itself. This word model should be tuned such that it predicts word-terminating bytes such as space fairly well, and then not grow beyond this size. Now we can describe the above word model in two ways: Either we have a word model that predicts words, and another model that predicts non-word spans, and a third ES that is an oscillator, and unconditionally switches between these, or, by multiplying the word ES and non-word-span ES, we the absorb the oscillator ES, since one pair of word and non-word-run events always follow each other, so one product of word \times non-word events following another is the product of all three of the previous ESs. This is just an example of using the event algebra to take a different perspective on an event stream. So with a single ES, we have a BPE-like approach, where we add events to the word ES that are useful. The word event plus the follower event has a nearly-constant entropy budget, and a constant pattern cost because each new one adds a new memory. All we have to do is only serialize the parts of the word model, which, at the point they first occur in the compressed data set, save more bits than their serialization costs. Then our word model is definitionally pure win in the hutter criteria. This is really what P8 was meant to be initially. Not replacing the letter model, but adding a word model to it without giving up the compression we already have. So the word model is simply this generalized function, which we've defined before, but may as well define it again here. In fact it's a bit complicated by the fact that the alignment of the word ES and the byte ES is not known in advance. That is, the word events occur at arbitrary positions in the byte stream. Therefore we arrive at the system mentioned above where words are defined by predicting a non-word event, such as space. The patterns we are getting are actually diverse, not everything going into space, but a lot of logical rules like q -> u, c -> h, '>' -> 0x0A (because of XML tags being on a line), '<' -> '/' (because of XML closing tags), comma and dot and semicolon all going to space, and so on. Word-follower events such as space implicitly terminate the word model, because it is a property of the dataset that extending words past spaces (or commas, etc) is generally not worth it. So we have the following: Let's start at the input ES and the first memory cell, one to the left (call it e_1). Then we can learn the Markov model in a single step, without the arbitrary model compression that we added by injecting the same model into every ring, by learning directly from e_1 to e_0 via LSA. Then if we state that only when e_1 is absolutely activated by the leftward chain pattern, the e_0 will be significantly activated, we already get the Markov distribution on the input ES for free. Then the replay of the memory chain is direct: we decode the gap lengths, read the surprise events, and inject them at the input ES, while letting the first-order model between the first memory cell and the input ES take care of everything else. This is the first change we make from p7. The decoding picture without settling includes the token model plus the M-1 model but is otherwise the same: bytes that were not the top prediction are recorded, all others are recreated. Settling will be introduced once we have more than one word being decoded at once, and will allow us to record fewer bytes. input in the next timestep, or from e_1 to e_0. However, we cut it down dramatically by only keeping the top prediction and also dropping the strengths. This means that our settling process won't work as well. So, step 1, we will add the "word" ES or perhaps we should call it a BPE ES or come up with some new name, since it's not limited to words anymore. Maybe it's just a "token" ES; that's generic enough but still suggestive of words. One issue with a greedy approach is that, if we limit the size to only a fixed number of patterns at k=2 we may be giving up patterns at k=3 that would be valuable, but that's a cost of a simple approach, which we can always backfill later. The main point of this push should be to get multiple levels of predictions competing, and work out the math, which is mostly about explaining why the simple update and learning rules we already have work, not adding any special code that is smuggled in via the translation to C. This is an issue we've had with Claude repeatedly before, and it's the primary reason for the P-programming / umr approach that we are taking now, where everything has to be explicit, up to performance optimizations. We ensure that explicitness by keeping the visibility layer, which is only in terms of the P-programming terms (E, T, P, f, \omega) and must always explain the outputs, regardless of how far the implementation diverges for efficiency's sake. In step 2 we will extend the M-1 model to include strength parameters without extending the number of patterns stored. So we will have 256 bytes for the M-1 (or k=1) pattern antecedents, but add 256 bytes for the strengths. This will help the settling work better. We will also have strength values for the k=2 and higher patterns, from the beginning. Also at this time, starting from step 1, we will have a new model format. Also we will introduce LSA, with a full complement of algebraic operations, even though we are only relying on addition or really even only on the increment operation. Note (added late since apparently the implementation is working around it): - everything that is LSA is calculated once and written into the model. It's stochastic when the model is learned, but the model is learned and then written into the compressed data file. Nothing about LSA being stochastic means that we need to recreate the same PRNG stream from the same seed (although that is good discipline for reproducability of course) for decompression to work. ``` ID: f-p8 Type: f This specifies f as necessary for p8v2 (the earlier p8 is obsolete). Per the answers in #pprog_p8v2_questions_20260727, this is the one place it gets defined, and it absorbs what would otherwise have been a separate arbitration block: there is no strict override of k=1 by k>=2 and no collision handling outside this block. So we are specifying the settling behavior, which emerges from P and the f we specify here. Dual to the trace sparsification rule in #omega-p8; the two have to be specified together. GENERATION 3 FOLDED FOUR THINGS INTO THIS BLOCK (#p8v2_gen3, choice F: "All of them"). Each had been decided in the parent-side C to get an implementation running and was stated nowhere a reader of the P-program could find it: the application rule, the window with its size and tiling, the clamping policy together with the readout's tie-break, and the initial state. They are now under THE RULES below. MJC's instruction with them: several are things he wants to explore dynamically, "so we may be adding some ambiguity back into f, from choices that were previously made by Claude in C code just to get an implementation up and running; these choices should get ramified through the visualization layer as variants". Where that applies it is marked AXIS CANDIDATE and generation 3's choices block asks which become axes. The word MESSAGE is gone from this design, per #p8v2_gen3 and #viz_standard's ruling. One iteration of settling is a TIME STEP IN f; what one pattern contributes to one position in a time step is a PATTERN APPLICATION. ## THE RULES THE STATE. One LSA activation vector of 256 entries per position of the window, over the byte ES (#byte). Entry x is the current log support for "the input byte here is x". This is T restricted to the window. THE WINDOW. Settling runs over a window of indeterminacy of W positions, W = 128 from #omega-p8-hyper, or whatever is left of the sample when that is smaller -- so a 64-byte sample is one window with W = 64. Windows are consecutive and NON-OVERLAPPING, beginning at 0, W, 2W and so on, and every position belongs to exactly one of them. AXIS CANDIDATE: both the tiling and W. A non- overlapping tiling means a position at a window edge settles from one side only, which is a property of the tiling and not of the model. #p8v2_gen3 on choice D wants to go further in this direction -- "not a sliding window at all, but a sequence of windows, once each one settles, then the next one comes up", with cross-window settling as a decode-cost-against-rate tunable. INITIALISATION. An unclamped position starts at 256 zeros. Nothing has reached it yet and 0 is the LSA floor, which is what "nothing is known here" is. There is no background state and no prior: the k=0 table that used to be read here was removed on 2026-08-06 because base frequencies applied outside P are not a pattern (#pprog_p8v2_gen1_choices). If a base rate is ever wanted, its correct form is a pattern from an always-present event, fired by f like any other. CLAMPING. A recorded position is clamped: 255 on its own byte event and 0 on the other 255, and it is never updated by a time step. That is the absolute of LSA -- the position is known -- and it is also exactly what the decoder has, which is the point: the encoder may only clamp what the decoder will also have. KNOWN DEFECT, and it is where generation 2's axis D failed to round-trip: the removal test settles a candidate with every OTHER recorded position clamped to the SAMPLE's bytes, while the decoder settles with the same clamped SET but with its own reconstruction in the unrecorded positions. The two are not the same state, so the encoder's "settling recovers this byte" does not survive to decode time. A TIME STEP. One synchronous time step: every application is computed from the state as it was at the start of the step, and all of them are written together at the end of it. A window runs W time steps -- one per position -- because an application travels one position per step and has to be able to cross the window before the state is read. AXIS CANDIDATE: the number of time steps, which is currently pinned to the window's own width for that reason and for no other. THE APPLICATION RULE (this was the "message rule" in #omega-p8-hyper until generation 3). A pattern of weight w_p driven by a source event at activation w_s contributes min(w_p, w_s) to its consequent: an application is as strong as its weakest link, so an absolute source delivers the pattern's full weight and a doubtful source caps it. FROZEN, and generation 3 confirms it -- #p8v2_gen3, choice B: "b1 is the rule." The form tried before it was w_p - (255 - w_s), read as LSA division by the source's doubt. It annihilates every non-absolute application: at these sample sizes a learned weight is 1 or 2 LSA units, so one hop off a clamped position takes everything to 0 and the whole window settles to byte 0. It is recorded because it is the kind of scaling mistake the generation exists to make visible, and because min() is the same arithmetic the AND gate already uses. THE k=1 STRENGTH. The k=1 section of the model file is 256 bytes of ARGMAX AND NOTHING ELSE, so the pattern's strength is not in the file: it is a constant of the design, and it is the SAME constant everywhere -- the generated settling, the replay reference, the query layer and the viewers. The strength is 8, delivered under the frozen application rule as min(8, w_s) in both directions, and it moves as a pair with a fall-off of 1 (#f-p8-cap8: the delivery and the fall-off only make sense together, so the pair is the unit). 8 is the weight that makes the argmax carry half the mass of an ES whose other 255 events sit at 0, and it is what the data says: the argmax successor carries 0.635 / 0.515 / 0.290 of its context's observations at e64 / e1k / e10k, and the weight expressing that share is 9 / 8 / 7 (tests/pprog/p8v2-k1-strength.py) -- so 8 is the measured value at e1k and within one unit of it at every sample size. A stated strength is a claim about partial knowledge, and the worked case shows why it matters: k1['m'] = 'e', and 'm' occurs at positions 1, 12, 29, 44 and 61 followed by e, l, e, l, l -- the rule holds twice in five occurrences in the only data there is. Under B2 the strength IS carried -- the stored 65536-byte matrix has the learned values -- so B2 is the ground truth any stated constant is scored against; the k=2 tokens carry their strength in the file and need no constant. Alternatives on axis A built before generation 4 keep the delivery they were measured with; the axis-A digit names which pair a variant ran. const: k1_strength = 8 THE ADMITTED OPTIMIZATION, with its unfolding (#um_optimizations). An application is computed from the SOURCE POSITION'S ARGMAX EVENT only, not from its whole distribution. Exact when the source is absolute, an approximation otherwise. The query layer unfolds it by naming the source event that produced each application. #p8v2_gen3 raises the price of this one: min "makes sense but somewhat ignores the rest of each ES", so the rest of the source ES has to be visible against the single event actually used. THE READOUT. A position's settled value is the argmax of its vector after the last time step, TIES GOING TO THE SMALLEST BYTE VALUE. AXIS CANDIDATE, and #p8v2_gen3 names it: a static tie-break rather than "dynamic settling effects breaking ties". It is not a formality -- at e64 most of the vector is zeros and ones, so the tie-break decides a large share of the answers, and it is the same class of hidden decision as generation 2's lsa_add nesting. WHAT VARIES. Given all of the above, what remains open is what a position DOES with the applications that reach it in a time step. That is axis A, and it is where generation 3 is working. ## LSA OPERATIONS USED BY f Every operation f performs, in ordinary arithmetic, so that no bare implementation identifier reaches a reader (#p8v2_gen3: "ordinary arithmetic, or LSA operations if a table is provided on the page that states what those operations are, no more lsa_ceil_log2"). LSA itself is defined in LSA.md; this is only the operation set this program uses. Columns are name, ordinary arithmetic, saturation, and whether the operation draws from the entropy stream -- the last column is what decides whether a reimplementation can reproduce a run. op: lsa_inc | w+1 with probability 1/2^w, else w | at 255 | draws w bits op: lsa_add | log2(2^a + 2^b): the larger of a and b, plus 1 with probability 1/2^d where d = abs(a-b) | at 255 | draws d bits op: lsa_sub | a-b when b= n; the LSA cost of choosing one of n alternatives | none | no The entropy stream is one xorshift32 sequence seeded at 0x5EED1234, SHARED between learning and settling. Two consequences, both load-bearing: any operation that draws makes the run's numbers irreproducible by a reimplementation that does not replay every prior draw in order (which is why a JS viewer can conformance-check A1 but not A2 or A3), and the ORDER in which drawing operations run is part of the definition, not an implementation detail -- see the accumulation nesting pinned in #pp_wordsv2, which was a real defect found in generation 2. THE CONSTANTS f USES, as data. Every numeric constant above, in one machine-readable place, lifted into axes.json exactly as the op: lines are, so no implementation holds its own copy and a viewer reads the number rather than restating it (#pprog_p8v2_gen4_goal_20260815, choice C). Alternatives that move a constant carry their own const: lines, which override these under that alternative. const: window_W = 128 const: time_steps_per_window = 128 const: clamp_weight = 255 const: entropy_seed = 0x5EED1234 ## THE ARGUMENT What follows is the derivation as written, unchanged, except that its closing passage is marked WITHDRAWN where generation 3 overturned it. An example of settling is the input "hello world" and the trace "h l w ", under a Markov model on letters and a token model. Considering only the first-order effects, we have the "hlw" events as absolute, and from these we have probabilities on all the later letters, as well as on tokens. Let's say we have some short words like "hi" which are compatible with "h l" but would require the token to be followed by another word char which is unlikely, but also compatible with "hill" and so on. So we define our token pattern precisely, it's a function (in one direction) from a sequence to a following byte. In the other direction, it's a probability distribution from bytes to tokens that come before them. In our example we have 11 bytes as a window of indeterminacy. This is an important parameter because it controls the cost of the settling process. So we have our patterns, already defined, but we'll define them again here, as generalizations of functions. First we generalize the function from a value to a distribution on the output space. Our functions are also bijections, so in fact we have a bijection from probability distributions on the input space to distributions on the output space. Then with this definition of a pattern, we only need to mention what the input space and output space are for each of the patterns we have. For our M-1 model on bytes, we have the input space and output space as a pair of adjacent byte. This means that one byte casts a shadow on the entire window. Diminishing returns mean that most of the calculations we would do would be irrelevant to the outcome, but within a limited window, we can disregard this effect and calculate everything. This means we can define a kind of settling process already even with just the M-1 model over bytes. Another definition of the M-1 pattern with one byte and the next byte being input and output spaces is that it is a sufficient statistic on the frequency of the joint events, i.e. the byte pairs. That is, the M-1 pattern, generalized, already induces, in the first order, a distribution over all the other bytes in the window. Taking the "h " state, we have probably some high distribution over the vowels in the second position, and then fairly quickly everything goes back to a background state. This background state, by the Markov property, returns to a static distribution. However, our patterns do not just carry a distribution but also have one more free parameter, which can be expressed as the total number of events from which the pattern is derived. If another pattern that is derived from a disjoint set of observations is brought in, these two distributions can be combined into the correct (per probability theory) combined distribution, which is not true if this additional parameter is not known (or if the observations are not disjoint, or more generally, are correlated in a way that is unknown). THAT FREE PARAMETER IS THE PATTERN'S SUPPORT, and generation 3's answer on axis A is built on it: see "What is open" below. LSA is the way we efficiently collect the sufficient statistic to characterize our pattern. On byte pairs, it is easy to see that all we need is the count of observations of each byte pair, but for a known bounded loss rate, all we actually need is the log count of observations with a bounded error rate, which is what LSA is designed to provide. LSA (log stochastic algebra) is defined by an increment rule, with addition, subtraction, multiplication and division derived in obvious ways. The increment rule takes a value $w$ which is a log estimate of an event count, and consumes $w$ bits of entropy. (Here, these $w$ are our T values in [0, 255].) The output of the increment operation is $w+1$ with probability $1/2^w$, and $w$ otherwise. Defining our token pattern: The input ES is a span of bytes, but this varies over sizes. So we can simplify the analysis by saying that it is the union of patterns of different lengths. We can define settling by starting from the goal of the process. The goal is that all information is integrated; that the answer is the probabilistically correct one given the information we have; that is is efficient to compute; and that the computation converges. Given that all of our patterns take time to be applied, and that applying a pattern always costs energy, we arrive at a specific approach: each atomic pattern fires at a specific rate; each atomic event activation (value in T) decays at a particular rate; pattern application is a simple operation on one atomic activation (t_i) given another (t_j) and a pattern (p_ij) between them. Given that we have already defined one simple operation on activation values, namely addition, (all operations hereinafter assumed to be LSA) we should see if this suffices. So, at a fixed frequency, we take the value of t_i and the weight p_ij, and find the value of t_j. First let us consider the case where t_i = 255, i.e. the antecedent event is absolute. Then we take as two candidate rules, either addition of p_ij to the current value of t_j, or assignment of p_ij as the new value of t_j. In the case of assigment, given the full joint pattern on the ESs in which t_i and t_j participate, we see immediately that softmax on the ES of t_j gives the correct probability distribution given the event e_i (corresponding to t_i = 255) and the information about the frequency of the joint events, the sufficient statistic, captured by the pattern. WITHDRAWN FROM HERE TO THE END OF THIS SECTION, by #p8v2_gen3's answer on choice A: "There is no constant sum ever in an ES. The only thing constant is total probability = 1 and that is after softmax. In an ES we are only ever talking about log support values, which don't have a constant sum. However, there is a constant sum in something like an m-1 model which is generated from a known DSS." The passage is kept because it is what #f-p8-add (A2) implements and therefore what generation 1 and generation 2 measured; it is no longer the justification for anything. Given a window of 11 bytes and the input "h ", i.e. $t_{1h} = 255$ we can say that the total information projected onto positions 2, 3, ..., 11 must be the same, and is the distribution that reverts to the frequency distribution over bytes, the M-0 model. Further, the information that we have at each position represents the same total number of observations. This is the second parameter that we mentioned which is independent of the distribution. This means that the sum is constant. Together these rules determine how the fall-off must work. If there is a fundamental frequency $f$ at which each atomic pattern is applied, then we have a rate $f$ at which this sum is copied from each memory cell to that to the left and right of it, or into it from the left and right, so we must have a fall-off at $2f$ to maintain the constant-sum invariant through time. This suggests that the settling process is now fixed and that $f$ is sufficiently constrained to be specified without any further decisions, only elaborating the consequences of those already made. (The result should be equivalent to other very well-known algorithms, and is nothing new.) ## WHAT IS OPEN Axis A, and #p8v2_gen3 gives the direction rather than the rule: firing depends on the probability interpretation of each ES; it stays in cheap integer operations on bytes; and the fall-off comes out of the patterns rather than being a subtracted constant. Its answer on the choices was a5 -- EACH PATTERN FIRES AT A RATE SET BY ITS OWN SUPPORT, the second parameter named in the derivation above. The two ends of the range are named there too: every event at w=1, where "the model is saying that we have seen every possibility happen once", and a w=255 antecedent, "an absolute rule from an absolute event"; and the case of one event at 255 with the rest at 1 or 2, where only the one event fires. Three things that answer does not settle, which generation 3's choices block asks: THE FORMULA. Support is an LSA byte; a rate is how often a pattern is applied. The map between them is not given, and the alternatives built for this generation are points in that family rather than a decision (#variant_protocol). WHERE SUPPORT COMES FROM AT DECODE TIME. This couples axis A to axis B. Under B1 the model file carries the 256-byte forward argmax table and nothing else, so the total count behind a k=1 rule is NOT in the file and the decoder cannot compute a rate from it; under B2 the whole 65536-byte matrix is there and a row or column sum recovers it. For k=2, learn_tokens already computes a per-context support (lsa_sum256 over its successors) but the token section stores only the argmax weight, so it is not serialized either. A rate set by support therefore either costs model bytes or must be derived from something the decoder already has. WHETHER IT MAY DRAW ENTROPY. A rate implemented by drawing from the stream (lsa_bits_zero at the support) is the natural LSA form, but it puts the axis in the same place as A2 and A3: not reproducible by a viewer that does not replay every draw, so not conformance-checkable, so not drivable in the visualization this generation is being designed in. A deterministic rate -- apply the pattern on the time steps where the step number divides its period -- is checkable, and the alternatives built here are deterministic for that reason. ``` We can elaborate a little further to describe the picture when k=0, k=1, ..., k=11 (to match the window size; larger tokens may even be collected in the model but will not match the window so will have no effect and may be ignored) are all added. Then we have patterns of the shape $(\emptyset, e_i)$, $(e_i, e_{i+1})$, ..., $((e_i, \ldots, e_{i+10}), e_11)$, where $(\cdot, \cdot)$ is the pattern between two events, and the inner $(\ldots)$ is a joint event. Then we can sum the incoming patterns on the final event $e_{11}$ and find that: - it has 10 antecedent ESs. - total influx energy is 10x a function of the DSS or total observed event count. This means that all of the dataset is represented at the final memory cell 10 times. The correlations between the token models of different lengths both explain this overcounting and show how it must correctly be accounted for. (the above section is incomplete) ``` ID: omega-p8 Type: Omega The learning rule: how the model architecture grows at runtime -- which events and patterns get created, scored, kept and pruned. In the UM, $\omega$ is the function that adjusts weights, and can also be a function that adds connections (atomic patterns $p_ij$) to P. In p8v2, this covers (say) k=0 through k=32, allowing tokens that cover most non-pathological English words, and with, say, N=1000, we can store everything without any pruning. Per the answers in #pprog_p8v2_questions_20260727 this also owns the hyperparameters (max k, patterns kept per k, scan length N), which are baked in here rather than declared anywhere else, and the sparsification of the top-level memory trace -- which bytes are recorded -- which is dual to settling in #f. The reason that \omega covers sparsification of the memory trace is because we consider the formation of a memory as a special case of learning; therefore it must be governed by the same mechanism. In the brain, if we imagine all we have are synapses and their strengths, then a memory must be formed by a set of changes in synaptic strengths. For now we can do something quite dumb here: - sparsify, once f is settled, by a greedy algorithm: - start with the memory trace of p7, which remembers every byte that was surprising under M-1. - find the first byte that can be removed without changing the most probable byte sequence under $f$, and remove it. ``` ``` ID: wordsv2 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1, token_predict, token_and, top_recall f: f-p8 Omega: omega-p8 summary: the memchain with the top-level joint event memory, now called enwik9 The token ES is a FAMILY, indexed by position and by length k, not a single ES: token_1 does not exist (it would duplicate mem_cell_1) and token_2 at a position is the projection of memory cells 1 and 2 onto the byte there, i.e. the two previous bytes onto the next. The E line above names the k=2 member at each of the N positions; k_max = 64 is the architecture, not this push. This block is the design, and it names the SPEC blocks (#f-p8, #omega-p8, #mem_cell_markov_1, #token_and), which state the problem rather than answering it. Generation 1 answers it on six axes, and the runs go through the variant program blocks #wordsv2-v001 .. #wordsv2-v011 at the end of this file. Running this block directly is the baseline: the interpreter maps a header id it does not recognise as an alternative onto the baseline of that axis and says so. ``` The token ES is grown at runtime by Omega, which also owns the sparsification of the top-level memory trace. Previous Q and A in #pprog_p8v2_questions_20260727. ## Carried over from p7 as-is #mem_cell_i ES template, parameter i #memchain pattern, parameter N #stdin_single_byte T, clock 200000 Hz #stdout_single_byte T ## Renamed #input -> #byte p7's name was already recorded as a wart in #pprog_explain_goal_20260722: on recall the "input" ES is the output. #byte says what it holds and says nothing about direction. Might change, because input is still at the right and output is still at the left. #top_mem -> #enwik9 the top-level joint-event singleton is named for the dataset it is the memory of, so that a serialized model is identified by its top-level memory event. See "still underspecified" (2): what the id is for the prefixes we actually run on is not settled. ## Revised, same role #top_recall From: #enwik9, To: the surprising subset of mem_cell_1, ..., mem_cell_N. The trace FORMAT is frozen exactly as p7 left it -- surprising bytes encoded directly, gaps unary after subtracting 1 -- but p7's definition of the surprising subset ("not predicted under argmax by the cell to the right under mem_cell_markov_1") no longer holds. #mem_cell_markov_1 p7 applied one learned M-1 pattern to every mem_cell_i; here it is applied over a settling region. ## New, to be written #token ES. #token_and The AND gate: how the k byte events at one time step fire the joint token event. A joint event over e_1 and e_0 at the same time step -- input summation and thresholding, the traditional neuron shape. This is new UM machinery, not a pattern in the existing sense, and it is the mechanism the whole token ES rests on. #token_predict Learned pattern template, parameter k. From: #token, To: #byte. k=1 is the old M-1 model; k=2 is the first new pattern of this push. Learned by LSI over the replayed trace, with strengths from the start at k>=2. #f-p8 Written (Type: f). Settling: how P is applied to T, including timing, the window of indeterminacy, the abduction step, and the collision between k=1 and k>=2. It absorbs what would otherwise have been an #arbitration block -- there is no strict override of k=1 by k>=2 and no collision handling anywhere else. #omega-p8 Written (Type: Omega). The learning rule: which token events and patterns are created, scored, kept and pruned; the hyperparameters (max k, patterns kept per k, scan length N) are baked in here rather than declared as program headers, because nothing tunes them at runtime; and the sparsification of the top-level memory trace lives here too, since forming a memory is a special case of learning. Dual to the settling rule in #f-p8: sparsification and decoding have to be specified together. Deliberately NOT separate blocks: arbitration (absorbed by #f-p8) and hyperparameters (absorbed by #omega-p8). ``` ID: token Type: ES-family Parameter: k Tokens are learned by a greedy collection process followed by a sparsification step. At first we run on minimal input lengths to understand what's happening by looking at the data. From p7 we have a learned model on byte ES to the subsequent byte ES, i.e. from each memory cell to the next. In p8v2 we upgrade this to be a full LPP on (byte, byte) joint events. Settling involves applying this at each position repeatedly. The M-1 model of p7 is the k=1 token model. This records the joint events on byte pairs using LSA. Like the memory cell ES, the token ES is parameterized by position, but also by token length k. The token-1 ES does not exist, as it would duplicate the memory-cell-1 ES which is one position to the left of the input ES. The token-2 ES records joint events of length 3, i.e. the projection of memory cells 1 and 2 onto the input ES, i.e. the previous two bytes onto the next. This entails the AND-gate. ``` The details of the AND gate, from a neuronal/synaptic bio-plausibility perspective, are not yet ironed out, but this doesn't matter currently, because our implementation is optimized anyway. However, as always, what does matter is that the reporting remains true to the model, so we define the AND-gate in terms of events in and events out. Specifically, an "a" event in memory cell n+1 and a "b" event in memory cell n creates a joint event "ab", if one has been created. They are created, and pruned, by #omega-p8, defined below. Once created, they operate in the obvious way: when both "a" is active and "b" is active then the "ab" joint event is active. However, as all our ESs are now moving to the probabilistic domain ($t \in [0,255]$, not only $\in {0,1,255}$ as previously), we have to define the joint probabilistic behavior. A simple and sufficient definition for now is min(w_a, w_b) where w is the weight (log support value). However, as we develop f we will move to a dynamic system where each neuron decays at a fixed rate, and fires at a fixed rate, and the behavior we want (hopefully) emerges from these interactions. This will be an exploratory process, more empirical than theory-driven. ## Step 1 / step 2 Step 1: k=2 only, so the first measurement isolates one lever. Settling is in scope, loosely -- getting it running and introspectable matters more than getting it right, and the model is not required to round-trip. LSI/LSA are in full from step 1, as is the new model format (one file). Step 2: strengths on k=1 (256 antecedent bytes plus 256 strength bytes). k>=2 has strengths already in step 1, so "strength 2 beats strength 1" never exists as a rule. Query-layer unfolding is a deliverable of this push, not a follow-up, per the standing discipline in #pprog_pattern_query_goal_20260706: --patterns must enumerate the (token, byte) ES pair and print those rules in SN, and --explain must add the k>=2 lines to the stack at a position where a joint rule fired (#pprog_explain_goal_20260722 anticipated this and said the surface does not change). This is also where the f and Omega decisions become visible at all. Not a target: p8v1's numbers. What this has to beat is p7 on the same samples at every M, which is close to guaranteed by construction as long as the k=2 patterns are encoded sanely. Failing to round-trip in the first runs is an acceptable and even expected outcome for step 1. ## Still underspecified 1. Is #token one ES whose events are spans of every length, or a family indexed by k? The union reading is what "the input ES is a span of bytes, but this varies over sizes ... the union of patterns of different lengths" in #f-p8 says, and it makes the k=1 seeding fall out; the k-indexed reading is what "a fixed size for the word model at every increase in k" and the per-k budgets suggest. The E header above assumes the union. This decides whether #token_predict has a k parameter or not. No. It is a family. 2. The dataset-named top-level ES. Naming the singleton #enwik9 is settled, but we run on prefixes, and a block id cannot vary per run. Either the id stays fixed and an instance header carries the size, or each fixture gets its own id. Tied to the model-on-disk convention, which is wanted ("models named by their top-level memory event") but not designed. I don't care, we'll just do something that works. The DSS is a runtime parameter, whatever that means. 3. The window of indeterminacy. #f-p8 works its example at 11 bytes; the prose above picks 32 as a max word length and the learning sketch uses k=8 cells. This parameter sets the cost of settling and the sizes have to be reconciled before anything is written. Let's pick 64, because it's too long for words and let's us exercise the pruning. 4. The fundamental frequency f and the pattern application rates. #f-p8 argues the constant-sum invariant fixes the fall-off at 2f given a rate f, and concludes settling "is now fixed ... only elaborating the consequences", but the elaboration is not written, and its own last section (the k=0..k=11 influx accounting, where the dataset is represented ten times over at the final cell and the correlations between token lengths have to account for the overcounting) is marked incomplete. It doesn't matter, we'll build what we can, build visualization layers for it, and go from there. 5. Assignment vs addition in the update. #f-p8 poses the two candidate operations for taking t_i and p_ij to t_j and shows assignment is correct in the t_i = 255 case, but does not rule for the general case, which is the case settling actually runs in. So the answer is that when k=2 is a subset of k=1 then assignment is correct because k=2 is a subset of the k=1 events, i.e. they are fully correlated. However, we are interested in the more general case, where it will be addition operating against decay at a specified frequency, which will also relate to the efficiency of implementation, which is why we are taking an empirical approach. 6. The backward direction of a pattern. Settling needs the M-1 pattern applied leftward as well as rightward. #f-p8 offers two options -- record the full LPP, or renormalize the backward direction from what we already store, "starting with LS summation on both sides" -- and defers. LSA.md does not define this normalization either. Correct. Let's implement and document something based on the p7 format that reconstructs the full LPP via normalization. Whether we stick with it or not remains to be seen. 7. The abduction rule. Restoring the memory chain leaves a synthetic input event at strength ~1 which has to be taken to 255. #f-p8 admits this is "not justified by any general mechanism" and exists to keep decoding tractable. It needs a written form even if it stays a quirk, because the sparsification rule is its dual. The jump to 255 is the dual of the sparsification of the memory chain. Because everything that is not the most likely is written directly, everything that is the most likely is true. I'm unclear why Claude thinks anything more needs to be written about this than already has been. 8. Sparsification. #omega-p8 gives a placeholder: greedily drop the first byte whose removal does not change the most probable byte sequence under f. That requires settling to a fixpoint per candidate byte, over a trace of DSS length, with no stated stopping rule or ordering, and it can only be finalized once (4)-(7) are. It's not DSS length, it's the uncertainty window, which for now could be limited to say 4 * k, with k=64, but really, we expect k=32 is going to catch most words, so let's say 4 * 32 = 128. 9. The keep/prune score for token events. Explicitly left open by the programmer: not the error-elimination count, not counting or data replay (LSI already captures that), but "probably based on sharpness", a mechanical rule over the patterns themselves. Undefined, and it is what makes the per-k budget mean anything. Yes, that is why we are running on small DSS, so we can avoid pruning until we have examples. Which your endless pedantry is preventing us from collecting. 10. The replay loop. The intent is to replay from p7 into p8 after every change in pattern shape, and repeat -- conceptually simpler than fusing the passes, which is an optimization. What ends the loop, and whether the k=1 table is relearned on each pass or frozen after the first, is not stated. N is described both as a hyperparameter and as budget-fill driven ("hold the space fixed, scan as much data as necessary to reach it"). 11. The AND gate's arithmetic: the summation and threshold, and what happens at partial matches, which is the normal case during settling. 12. SN rendering of a token. --patterns prints rules in SN; a variable-length joint event over byte events has no SN form yet, and #token_predict's rules are the thing this push most needs to read. Memory cell events have a form, this is directly analogous. "The 3-token at position 3 is "abc"." 0 13. Interpreter-side, out of scope here but noted so it is not lost: no f: header exists today -- #run_ofra_strip_goal_20260729 records that kind detection substring-matches "Omega:" -- and #pprog_p8_hapax_serialization_goal_20260706 proposed lifting the model format into its own serialization document. A new model format is required from step 1 either way. ## Generation 1 (2026-08-04) Written for #pprog_p8v2_impl_goal_20260804 under the variant protocol (#variant_protocol): where the design is open we do not rule, we build every reasonable answer and look at them together. Everything below this line is generation 1: the blocks carried over from p7, the blocks the push needs that did not exist, the ALTERNATIVES on each of the six open axes, and the VARIANT program blocks that name them. An alternative is an OFRA block that replaces exactly one block of the baseline; its id suffixes the block it replaces. A variant is a program block that names the alternatives it uses in its E/T/P/f/Omega headers. The interpreter resolves headers by id, so a variant costs no CLI surface: cmpr --run '#wordsv2-v004' --ofra tests/pprog/p8v2-words.md 1024 --compress /tmp/m The axes, and the id in each header slot that selects each alternative: A settling update f: f-p8-assign (A1) | f-p8-add (A2) | f-p8-renorm (A3) B backward M-1 P: mem_cell_markov_1-norm (B1) | mem_cell_markov_1-lpp (B2) C AND gate arithmetic P: token_and-min (C1) | token_and-sum (C2) D sparsification Omega: omega-p8-frozen (D1) | omega-p8-settled (D2) | omega-p8-greedy (D3) E replay Omega: omega-p8-replay-1 (E1) | omega-p8-replay-2 (E2) | omega-p8-replay-dry (E3) F token keep/prune Omega: omega-p8-keep-all (F1) | omega-p8-keep-support (F2) | omega-p8-keep-sharp (F3) The baseline vector is A1 B1 C1 D1 E1 F1 and it is #wordsv2-v001. A generation is the baseline plus one variant per non-baseline alternative -- 1 + (2+1+1+2+2+2) = 11 runs, not the 324 of the cross product. (The goal block says 8; with the six axes as it lists them the protocol's own formula gives 11. See "Open after generation 1" at the end of this file.) The Omega: header is a LIST, like P:, because three axes live in omega and each has to be varied on its own. #omega-p8-hyper appears in every variant and carries the frozen numbers. ### Carried over from p7, byte-identical ``` ID: mem_cell_i Type: ES template Parameters: i "The input byte i time steps ago was X." ``` ``` ID: memchain Type: pattern Parameter: length N. "The input byte is X." -> "The input byte 1 time steps ago was X." 255. ``` ``` ID: stdin_single_byte Type: T clock: 200000 Hz (pinned, read by the interpreter from this header; ~200 kHz, of the order of the ~278 kHz Hutter-budget rate from #mc_pattern_design). ``` ``` ID: stdout_single_byte Type: T Writes bytes to stdout at the same clock rate, once they are written to output ES. ``` ### Renamed from p7 ``` ID: byte Type: ES p7's #input. The name said which direction the bytes were travelling, which was wrong half the time: on recall this ES is the output. #byte says what it holds and says nothing about direction. Events: one per byte value. SN: "The input byte is X." (the sentence keeps p7's wording so that carried-over patterns and the query layer stay byte-identical; only the block id changed). ``` ``` ID: enwik9 Type: ES p7's #top_mem: the singleton top-level joint event, the whole memory of which the trace is the serialization. Named for the dataset it is the memory of, so a serialized model is identified by its top-level memory event. We run on prefixes, and a block id cannot vary per run, so the id stays fixed and the size is a runtime parameter (the DSS): the model file header carries M. SN: "The top-level memory event is present." ``` ### Revised from p7, same role ``` ID: mem_cell_markov_1 Type: pattern The k=1 member of the token family: a learned pattern from one byte event to the byte event at the next time step. p7 applied it to every mem_cell_i and learned it in one place; here it is applied over the settling region, in both directions, so it is stated once as an interior pattern on the byte ES from one time step to the next. Learned by LSA over the sample: an LSA value per ordered byte pair, incremented once per adjacent occurrence. What is SERIALIZED, and how the BACKWARD direction is obtained from it, is axis B -- see #mem_cell_markov_1-norm and #mem_cell_markov_1-lpp. Both learn the same 65536 LSA values; they differ only in what survives into the model file. The forward argmax table (256 bytes: for each byte the most likely successor) is p7's table and is present in every variant. Strengths on k=1 are step 2 and are not in this push; k>=2 has strengths from the start, so "strength 2 beats strength 1" never exists as a rule. ``` ``` ID: top_recall Type: pattern From: enwik9 To: the surprising subset of mem_cell_1, ..., mem_cell_N From the enwik9 singleton onto the memory chain, but only onto the SURPRISING cells. The trace FORMAT is frozen exactly as p7 left it -- surprising bytes encoded directly, gaps unary after subtracting 1 -- but p7's predicate ("not predicted under argmax by the cell to the right under mem_cell_markov_1") no longer holds, because the predictor is now the composite of the k=1 and k=2 patterns, and because a byte can also be recovered from its RIGHT neighbour once settling runs. Which bytes are surprising is therefore not decided here. It is decided by omega, because forming a memory is a special case of learning, and it is axis D: #omega-p8-frozen, #omega-p8-settled, #omega-p8-greedy. Sparsification and settling are duals and are specified together (#f-p8). The abduction step needs no rule of its own: everything that is not most likely is written directly, therefore everything most likely is true, therefore the synthetic event restoring the chain goes to 255. That is the dual of sparsification, not an extra mechanism. ``` ### New for p8v2 ``` ID: token_predict Type: pattern template Parameter: k From: token_k To: byte The learned rule of the token family: from a k-token event (a joint event over the k byte events immediately to the left of a position) to the byte event at that position. k=1 is #mem_cell_markov_1, the old M-1 model. k=2 is the first new pattern of this push: the antecedent is the joint event over the two preceding bytes. Learned by LSA over the replayed trace: for each observed k-token an LSA value per successor byte, incremented once per occurrence. What is KEPT is #token_predict's own economy and belongs to omega (axis F): a kept rule is (the k-token, its most likely successor, the LSA strength of that successor), four bytes at k=2. The rest of the successor distribution is not serialized, because the only prediction the rule makes is its argmax and the only strength that matters is that one's -- which is what makes the token model a lexicon with a weight per entry. SN of a token event, per the answer in #pprog_p8v2_questions_20260727: "The 2-token at position 3 is "ab"." 0. with the position being the token's START position. In the position-free form used by --patterns to print RULES rather than instances, the "at position N" clause is dropped: "The 2-token is "ab"." "The input byte is c." 37. ``` ``` ID: token_and Type: AND gate The first true AND gate in the UM: the mechanism by which the k byte events at one position fire the joint k-token event. Not a pattern in the existing sense -- a pattern relates events at different time steps, this relates events at the same one. Events in, events out: an "a" event in memory cell n+1 and a "b" event in memory cell n make the joint event "ab" active, if that joint event has been created (creation and pruning are omega's, see #omega-p8-keep-all and its alternatives). While every activation was in {0, 1, 255} this was the whole story. Now that activations live in [0,255] the gate needs an arithmetic at PARTIAL activation, which is the normal case during settling. That is axis C: #token_and-min, #token_and-sum. Admitted optimization, with its unfolding: the gate is evaluated only for the pair formed by the most active event at each of the two source positions, not for all 65536 pairs. This is exact whenever the sources are absolute (the clamped case) and is an approximation elsewhere; the query layer unfolds it by naming, at any position, the token that fired and the two source events that fired it. ``` ``` ID: omega-p8-hyper Type: Omega The hyperparameters: pre-committed aspects of the shape of the total pattern. They live in omega because that is what omega is -- the rule by which the model architecture grows -- and nothing tunes them at runtime. Every variant of generation 1 names this block, so they are frozen across the whole generation and the runs stay comparable. k 2, and only 2. k_max = 64 is the architecture, not this push. W 128 bytes, the window of indeterminacy (4 * 32; 32 is the token length expected to catch most words). Settling never looks outside it. A window is W positions or whatever is left of the sample, whichever is smaller, so a 64-byte sample is one window with W = 64. window tiling consecutive and NON-OVERLAPPING: windows begin at 0, W, 2W and so on, and a position belongs to exactly one of them. FOLDED BACK IN GENERATION 3 -- this was decided in the C and never written down here, and it is why a position near a window edge settles from one side only. time steps in f W per window: one per position of the window, because a pattern application travels one position per time step and has to be able to cross the window before the state is read. token max length 64. budget per k 256 kept rules at k=2, for the alternatives that have a budget at all (#omega-p8-keep-support, #omega-p8-keep-sharp). At step-1 sizes it does not bind, which is the point of running on a small DSS. replay cap 4 rounds, for #omega-p8-replay-dry. AND threshold 128, for #token_and-sum. LSA values are bytes in [0,255] read as log2 counts; increment gives w+1 with probability 1/2^w (LSA.md at the repo root). The entropy is drawn from a xorshift32 stream seeded at 0x5EED1234 so that a run is reproducible. DSS a runtime parameter: the chain length N from the command line, and M = the bytes actually resident. THE APPLICATION RULE MOVED OUT OF THIS BLOCK IN GENERATION 3. It used to sit here as the "message rule". It is not a hyperparameter -- it is what f does with a pattern and a source activation -- and #p8v2_gen3 asks for f to be described in one place, so it now lives in #f-p8 with the rest of f. MJC's answer on generation 3's choice B: min(w_p, w_s) is the rule and it stays frozen. const: k = 2 const: token_max_length = 64 const: budget_per_k = 256 const: replay_cap = 4 const: and_threshold = 128 ``` ### Axis A -- the settling update Question: what does a position DO with the pattern applications that reach it: keep only the longest context that fired, accumulate them against a decay, or accumulate them and renormalise to a constant sum? Watch: settled_ok and conv, in the TSV and the .pos dumps. Under D1 axis A moves what settling produces at every position without moving the trace, so a rate that does not move is not evidence that the axis does nothing. THE SETTLING SHELL MOVED TO #f-p8 IN GENERATION 3, on MJC's answer to choice F ("all of them"). It used to be described here: the window and its W, the non-overlapping tiling, the recorded bytes clamped absolute, every other position initialised to 256 zeros, the W time steps, the application rule, and the argmax readout with its tie-break. All of that is f rather than axis A, and #p8v2_gen3 asks for f to be described in one place. What is left in this section is the axis itself -- what a position does with the applications that reach it -- and the history below. Generation 3's direction on this axis, from #p8v2_gen3: A1 is "gone"; A3 "was not anything that I wanted"; A2 "is the promising direction", but "the implementation of A2 interpreted this as 'subtracting 2' from every event, which is not what we meant, but it's something". The replacement is answer a5 -- each pattern fires at a rate set by its own support -- with the constant-sum argument that produced the 2 explicitly withdrawn. See "What is open" in #f-p8. This said "24 synchronous sweeps" until 2026-08-05. Q7 changed it to W and the runs have done W ever since; v001 at e64 reports conv 27, which 24 time steps cannot produce. The prose was stale and the runs were right. (The word "sweep" itself went in generation 3: one settling iteration is a TIME STEP IN f. The .pos and TSV columns keep their names -- mean_sweeps is a data column, not a term of art.) This said "initialized to the k=0 background" until 2026-08-06. THE k=0 BACKGROUND IS GONE. It was a 256-byte byte-frequency table the implementation read directly, outside P: not in #wordsv2's P header, zero atomic patterns in the structural line, unnameable by --patterns. Base frequencies applied that way are not a pattern, and the ruling (#pprog_p8v2_gen1_choices, carried out in generation 2) is that nothing replaces them -- the k=1 model and settling converge to the character frequency anyway, so if the base rate were needed it would be available. The correct form, if one is ever wanted, is a pattern from an always-present "true" event fired by f like any other. Three places read it and all three now say the honest thing: an unclamped position starts at 256 zeros, #f-p8-assign assigns 256 zeros when nothing fires, and #mem_cell_markov_1-norm makes no backward application when the byte has no predecessor. The model file lost its first 256-byte section with it; see "What every variant reports". Full account in #pp_wordsv2. Admitted optimization, with its unfolding: an application is computed from the SOURCE POSITION'S ARGMAX event only, not from its whole distribution. Exact when the source is absolute; an approximation elsewhere. The query layer unfolds it by naming the source event that produced each application. ``` ID: f-p8-assign Type: f A1. ASSIGNMENT: the longest k that fires wins outright, and nothing accumulates. If a k=2 token application reaches this position, the position's new state IS what that application delivered; otherwise it is the elementwise LSA maximum of the forward and backward k=1 applications; if neither fires, 256 zeros. Nothing accumulates. A position's state is whatever one application said last, and the forward, backward and token evidence never combine. There are no rates in it at all, which makes it the simplest rule on the axis and the control that shows what accumulation buys. It is also the one alternative on this axis whose settling draws no entropy, so it can be conformance-checked against a reimplementation position by position, which is what makes it drivable in a viewer. PRUNED, and kept runnable because #wordsv2-v001 is a real run whose numbers are on the record. HISTORY. Generation 1's baseline. PRUNED generation 1 (#pprog_p8v2_gen1_choices: "A1 is wrong; goes away"), because assignment discards every application but the longest that fires, so nothing accumulates and the axis has nowhere to go. No generation-2 variant names it and the generation-2 baseline is #wordsv2-v002. Generation 3 (#p8v2_gen3) confirms the prune and adds the use above: "A1 was already pruned, but it's still interesting as a use case for visualization." The "if neither fires" arm read "the k=0 background" until 2026-08-06; see the Axis A shell above. WHY. #f-p8 shows assignment is correct when the antecedent is absolute, and notes that k=2 is a subset of k=1 -- they are fully correlated -- so it is correct there too. ``` ``` ID: f-p8-add Type: f A2. LSA ADDITION against DECAY: the position's state accumulates every pattern application that reaches it (LSA addition, per entry), and then decays. One time step is one application of each pattern, and decays every unclamped entry by 2 LSA units, floored at 0. This is the general case #f-p8 declines to rule on, and the one settling actually runs in. const: falloff = 2 HISTORY. The 2 came from the constant-sum argument in #f-p8: if each atomic pattern is applied at rate f, then the sum at a cell is copied to the cells left and right of it at rate f each, so the fall-off must be 2f for the total to be invariant. THAT ARGUMENT WAS WITHDRAWN BY MJC IN GENERATION 3, and the alternative is kept as the generation-2 baseline and control rather than being corrected in place. #p8v2_gen3, answering choice A: "There is no constant sum ever in an ES. The only thing constant is total probability = 1 and that is after softmax. In an ES we are only ever talking about log support values, which don't have a constant sum." And on this implementation: "The implementation of A2 interpreted this as 'subtracting 2' from every event, which is not what we meant, but it's something." So the rule stands as built and as measured; what falls is its derivation. LATER. The replacement direction is a rate set by each pattern's own support -- see #f-p8's "What is open" and the generation-3 alternatives on this axis. ``` ``` ID: f-p8-renorm Type: f A3. LSA addition with NO decay, renormalized per position to constant sum. Same accumulation as #f-p8-add, but instead of a decay rate the invariant is imposed directly: after each time step every unclamped position's LSA sum is brought back to 255, the sum a clamped position carries, by subtracting the excess from every entry. Against #f-p8-add it separates two things that alternative confounds: whether the constant-sum invariant is doing the work, or the rate at which it is approached is. PRUNED, and kept runnable because #wordsv2-v003 is on the record. HISTORY. PRUNED generation 3 (#p8v2_gen3: "A3 was not anything that I wanted, although I may have mentioned something about renormalization, but it wasn't this"; the prune confirmed on generation 3's choice E). The invariant it imposes is the one the same answer rules out: an ES of log support values has no constant sum. WHY. Generation 2 measured it as free on the rate and half the time steps to converge, so the control still shows what imposing the invariant directly costs, against a fall-off that only approaches it. ``` ``` ID: f-p8-deficit Type: f A4. The decay is not a constant: a position decays by the SUPPORT DEFICIT of the strongest evidence that reached it. Same accumulation as #f-p8-add, and then that decay: Let s be the largest support among the applications that fired here this time step, and let the reference support be smax; the position decays by smax - s, floored at 0. In LSA a rate of one in 2^d is a subtraction of d, so a fall-off written as a subtraction IS a rate, and this one is set by the pattern: evidence as well supported as the best-supported pattern in the model does not decay at all, and evidence seen half as often loses one LSA unit per time step. The two ends #p8v2_gen3 names fall out -- an absolute rule from an absolute event persists, and a pattern that has seen every possibility once fades immediately. Deterministic: it draws no entropy of its own, so unlike A2 and A3 it can be reproduced by a reimplementation without replaying the stream, which is what makes it drivable in the viewer. AS BUILT, and these are the numbers the runs used rather than what should win. smax is the largest learned weight over the k=1 argmax pairs and over the kept k=2 rules, floored at 1: 2 at e64, 6 at e1k, 9 at e10k. A pattern's own support s_p is the LEARNED weight -- for k=1 it is c1[a*256 + table[a]] and for k=2 it is the rule's stored weight -- so a k=1 pattern here simultaneously DELIVERS at the absolute 255 and has a rate set by a support of 0, 1 or 2. That is the k=1 strength gap of #f-p8 appearing inside this alternative, not beside it. At e64, 229 of the 256 sup1 entries are 0, a byte never seen as a predecessor. Support is read from the learned tables, which under B1 are in memory but NOT in the model file; see the k=1 strength section of #f-p8. Under the D1 baseline settling never runs at decode time, so this alternative is measurable as it stands. HISTORY. Generation 3, and the first of the three alternatives built for MJC's answer a5 -- "each pattern fires at a rate set by its own support". A2 set the rate to the constant 2 because there are two neighbours and the sum had to be invariant, and that argument is withdrawn (#f-p8). WHY. The reference support smax is a sub-parameter, not a decision this block makes: built as the largest support present in the model, because the other obvious choice -- 255, the absolute -- makes the deficit 253 or 254 at these sample sizes and annihilates everything, which is exactly the failure recorded against w_p - (255 - w_s) in #f-p8. LATER. Generation 3's choices ask which the reference support should be. Combining this alternative with D2 or D3 would need the support serialized. ``` ``` ID: f-p8-period Type: f A5. The rate is a schedule rather than an attenuation, and there is no decay at all. A pattern of support s is applied only on the time steps where the step number is a multiple of 2^(smax - s), so the best-supported pattern in the model is applied on every step, one at half that support on every second step, and so on. What an application delivers is unchanged; how often it happens is the axis. A window runs W time steps, so A PATTERN WHOSE PERIOD EXCEEDS W NEVER FIRES INSIDE A WINDOW at all, and that is not hypothetical: the period is 2^(smax - s_p) and W is 128, so at e64 the periods are 1, 2 or 4 and everything fires; at e1k they reach 64; at e10k they reach 512 and a support-0 pattern never fires inside a window, which at that sample is 169 of the 256 bytes. The fall-off is implicit: nothing is subtracted, and a position's state stops growing simply because the patterns feeding it are applied less often. AS BUILT IT ALSO BUYS NOTHING. The three vectors are computed, and settle_apps counted, BEFORE the period decides whether to apply them, so a skipped application costs what a taken one costs. #f-p8's derivation says applying a pattern always costs energy, which is the whole reason a rate is a rate; an implementation that meant it would decide before computing. Recorded rather than fixed, because changing it changes what was measured. AS BUILT, and these are the numbers the runs used rather than what should win. smax is the largest learned weight over the k=1 argmax pairs and over the kept k=2 rules, floored at 1: 2 at e64, 6 at e1k, 9 at e10k. A pattern's own support s_p is the LEARNED weight -- for k=1 it is c1[a*256 + table[a]] and for k=2 it is the rule's stored weight -- so a k=1 pattern here simultaneously DELIVERS at the absolute 255 and has a rate set by a support of 0, 1 or 2. That is the k=1 strength gap of #f-p8 appearing inside this alternative, not beside it. At e64, 229 of the 256 sup1 entries are 0, a byte never seen as a predecessor. Deterministic, for the same reason as #f-p8-deficit, and with the same note about where support comes from and about the reference support smax. HISTORY. Generation 3, the literal reading of "each pattern fires at a rate set by its own support". WHY. This is the alternative that takes the word "rate" at face value. Whether never firing is the right behaviour for weak evidence or a defect is the sort of thing the generation exists to look at rather than to argue about. LATER. If a constant-sum-like behaviour is wanted, this is where it would have to come from, and it would come from the rates rather than from an invariant imposed after the fact. ``` ``` ID: f-p8-indegree Type: f A6. The decay is the NUMBER OF APPLICATIONS THAT ACTUALLY ARRIVED, rather than the constant 2. Same accumulation and the same shape of decay as #f-p8-add, counting fwd_fired plus bwd_fired plus tok_fired. A position that two patterns reached decays by 2, one that three reached decays by 3, and one that nothing reached does not decay at all. It therefore differs from A2 exactly where applications are missing -- the first and last positions of a window, positions before the second byte where no token context exists, and every position whose backward direction has an empty predecessor set under B1, which at e64 is 218 of the 256 bytes. Under A2 those positions decay at the full rate while receiving less than the full evidence. It needs no support at all, so unlike #f-p8-deficit and #f-p8-period it is unaffected by the k=1 strength gap and by axis B. HISTORY. Generation 3, and the smallest correction that removes the withdrawn argument. The 2 in A2 was the count of neighbours: information flows in from the left and from the right at rate f each, so the fall-off had to be 2f for the sum to stay invariant (#f-p8, the withdrawn passage). WHY. The invariant is gone, but the counting was never the questionable part. This alternative keeps the counting and drops the assumption. ``` ``` ID: f-p8-cap8 Type: f A7. The k=1 argmax pattern has strength 8, and the fall-off is 1. DELIVERY. A k=1 application under B1 delivers min(8, w_s): forward, fwd[table[a]] = min(8, wsrc); backward, each predecessor a of b gets min(8, wsrc - ceil(log2 |preds|)) with the subtraction saturating at 0. The forward and backward applications are thereby the same rule with the same w_p. Under B2 the stored weights are the delivery and this alternative's only effect is the fall-off. The k=2 token applications are unchanged: their strength is in the file. FALL-OFF. The update is #f-p8-add's accumulation (LSA addition, vector-outer entry-inner nesting), with the decay 1 instead of 2. const: k1_strength = 8 const: falloff = 1 HISTORY. Generation 4 (#pprog_p8v2_gen4_goal_20260815). The two constants moved together because the delivery and the fall-off only make sense as a pair; the pair was the unit, which is how the no-cross-product rule was kept. Generation 5 splits them into axes G and H, and this alternative is what both were carved out of. WHY. 8 is the weight that makes the argmax carry half the mass of an ES whose other 255 events sit at 0, and the measured share of the argmax at its contexts expresses as 9 / 8 / 7 at e64 / e1k / e10k (tests/pprog/p8v2-k1-strength.py), so it is the measured value at e1k and within one unit of it at every sample size. Measured before it was built, unrecorded positions settling back to their true byte at e1k, v002 retained models: the pair recovers 223 of 833 against the generation-3 baseline's 165, converging at time step 16 against 47; either constant moved alone does worse than moving neither. The grid is in the generation-4 goal block and reproduces from the retained models with p8v2-k1-strength.py. ``` ### Axis G -- the forward pass, what a k=1 application delivers Byte: 42 Question: how strong is a k=1 application, given that the model file stores an argmax and no weight at all, so the strength is a constant of the design rather than a learned quantity? Watch: that every row of the H ladder sits at the SAME delivery, which is what having this axis separately buys -- a difference between two decay rules is now a difference in decay alone. Two things say so on the page: byte 42 reads 1 in every variant that names the split (v026..v031) and is unwritten in the two carried over from generation 4, where an unnamed axis resolves to its baseline digit and is the same rule; and no entry a k=1 application wrote is ever above 8 in the f panel. ### Axis H -- the decay, what a position does with the applications that reach it Byte: 43 Question: with the delivery held fixed, which decay rule is doing the work: a constant, a rate set by each pattern's own support, a count of what arrived, or a renormalisation of how much evidence the position claims? Watch: settled_ok, conv and bpc on the ladder, at all three samples, and the .pos dumps behind them. Read every row against the constraint that a UNIFORM fall-off cannot reorder an ES -- lsa_sub is monotone, so only the 0 floor can change an argmax -- which means an alternative here is visible only through the floor, through what the next time step accumulates, or by differing between the patterns feeding ONE position. H2 is the row to check first: it draws no entropy, so it must conform exactly. ``` ID: f-p8-forward Type: f G1. A k=1 application delivers min(8, w_s). Forward, fwd[table[a]] = min(8, wsrc). Backward, each predecessor a of b gets min(8, lsa_sub(wsrc, ceil(log2 |preds|))), the subtraction saturating at 0. Forward and backward agree on w_p. Under B2 the stored weights are the delivery and this axis has no effect at all. The k=2 token applications are never on this axis: their strength is in the file. const: k1_strength = 8 HISTORY. Generation 5 (#pprog_p8v2_gen5_goal_20260815) carved this axis out of #f-p8-cap8 so that delivery and decay vary separately, on MJC's instruction opening the generation. Until generation 4 the two were one axis, which is why generation 4 had to make "the pair" the unit and why #f-p8-deficit and #f-p8-period carried the k=1 strength gap inside themselves -- an alternative that changed the rate could not hold the delivery still. The rule above is #f-p8-cap8's, byte for byte. WHY. 8 is the weight that makes the argmax carry half the mass of an ES whose other 255 events sit at 0, and the argmax's measured share at its contexts expresses as 9 / 8 / 7 at e64 / e1k / e10k (tests/pprog/p8v2-k1-strength.py). LATER. The alternatives this axis exists for are already measured as rows of the generation-4 grid and are NOT built in generation 5, which moves the decay axis only. Pass-through: deliver w_s unchanged, the honest name for the 255 that generation 4 extirpated, 255 being the identity of min. Attenuate: deliver lsa_sub(w_s, c) rather than a cap, which is the only form in which a strength of 1 can be applied at all -- min(1, w_s) puts the whole window in a 0-to-1 band where the stochastic add is noise and recovers 18 of 833. ``` ``` ID: f-p8-decay Type: f H1. Accumulate every application that fires, then subtract a constant fall-off of 1. THE RULE. #f-p8-add's accumulation -- copy the position's row into an accumulator, then for each application that fired, in the order forward, backward, token, make a COMPLETE pass over all 256 entries with lsa_add before the next one begins (the nesting is application-outer, entry-inner and is part of the definition, because lsa_add draws from the shared entropy stream) -- and then lsa_sub(entry, 1) on every one of the 256 entries, floored at 0. const: falloff = 1 THE STANDING CONSTRAINT ON EVERY ALTERNATIVE OF THIS AXIS, from generation 3's finding: a UNIFORM fall-off CANNOT REORDER AN ES. lsa_sub is monotone, so subtracting the same amount from every entry leaves the argmax exactly where it was; only the 0 floor can change it. An alternative that varies the rate between positions or between time steps acts through the floor and through what the next step accumulates; an alternative that varies it between the patterns feeding ONE position is the only kind that can reorder anything directly. Read every measurement on this axis against that. HISTORY. Generation 5 (#pprog_p8v2_gen5_goal_20260815) carved this axis out of #f-p8-cap8 and held it at the pair's fall-off. Generation 4 measured that the whole gain from 165 to 223 recovered positions at e1k, and the convergence from time step 47 to 16, was THE FALL-OFF and not the strength -- but it could only say so by moving both and reasoning about a grid. With the delivery held fixed on axis G it is an axis, and the generation's question is clean for the first time: which decay rule is doing the work? ``` ``` ID: f-p8-decay-assign Type: f H2. ASSIGNMENT: the longest k that fires wins outright, and there is no accumulation and therefore no decay at all. If a k=2 token application reaches this position, the position's new state IS what that application delivered; otherwise it is the elementwise LSA maximum of the forward and backward k=1 applications; if neither fires, 256 zeros. The axis's degenerate point, and the control that shows what accumulating buys once the delivery is no longer saturating. It is the one alternative on either f axis whose settling DRAWS NO ENTROPY, which is what makes it conformance-checkable in a viewer without replaying the stream. HISTORY. Generation 5, A1's idea (#f-p8-assign) restated on the cap-8 delivery. A1 ran with the k=1 delivery at 255, so an assignment wrote a saturated row: one entry at 255 and the rest at 0, a position claiming absolute knowledge from a rule that holds twice in five occurrences. At the cap-8 delivery an assignment writes 8 and the rest 0, which is a claim of partial knowledge, and the readout's tie-break stops deciding a large share of the answers by default. WHY. Pruned as a design in generation 1 and not un-pruned here: it is built because the generation restates all six, and because a control that draws no entropy is worth having (#p8v2_gen3 wanted it kept for exactly that). ``` ``` ID: f-p8-decay-const2 Type: f H3. The same accumulation as the baseline, with a constant fall-off of 2 instead of 1. const: falloff = 2 THE ONE-CONSTANT CONTROL. With #f-p8-decay's (8, 1) and generation 4's retained (255, 2) runs, this is (8, 2): the corner of the square that was never measured. The attribution of generation 4's gain stops being an inference from a Python grid and becomes three runs. HISTORY. Generation 5, A2's idea (#f-p8-add) restated on the cap-8 delivery. Generation 4 could only compare (255, 2) against (8, 1); the two constants moved together and the grid had to argue which one carried the gain. The derivation the 2 came from -- each atomic pattern applied at rate f, the sum copied to both neighbours at rate f each, so the fall-off must be 2f -- was WITHDRAWN by MJC in generation 3: there is no constant sum in an ES. The 2 survives here as a measured constant with no argument behind it, which is exactly what a control is. ``` ``` ID: f-p8-decay-renorm Type: f H4. Accumulate as the baseline does, then set the position's total support to what the arriving evidence justifies, rather than to a constant. THE RULE. Let s be lsa_sum256 of the accumulated vector, and let the target t be the LSA sum -- lsa_add folded, not the maximum -- of the supports of the applications that fired at this position on this time step, which is the correct combination when the applications come from disjoint observations, per the second free parameter in #f-p8's derivation. Subtract lsa_sub(s, t) from every one of the 256 entries, floored at 0. When nothing fired, t is 0 and the position decays to the floor. When s is at or below t nothing is subtracted. WHAT A UNIFORM SUBTRACTION CAN AND CANNOT DO, which is what this alternative rests on. Subtracting a constant d from every entry of a position's vector divides every count it represents by 2^d. That leaves the softmax distribution EXACTLY unchanged and changes only the total number of observations the position claims to rest on. So a renormalisation is never a statement about WHICH byte the position favours; it is only ever a statement about HOW MUCH EVIDENCE the position represents. WHAT TO EXPECT, stated before the run so the measurement can contradict it: because the subtraction is uniform it cannot reorder the ES, so every effect this alternative has arrives through the 0 floor and through what the next time step accumulates on top of a rescaled row. Its interest is not the settled bytes but the CONFIDENCE the settled state reports -- it is the only alternative on this axis whose vectors mean the same thing at time step 5 and at time step 100. HISTORY. Generation 5, A3's idea (#f-p8-renorm) restated, and the restatement is a correction. A3 renormalised to a sum of 255 and was read as imposing an invariant on the distribution, which is both the thing #p8v2_gen3 ruled out ("there is no constant sum ever in an ES") and a thing the operation cannot do. MJC on this generation's choice C: "Renormalization was never understood correctly by the model... 'along the same lines' is fine if you interpret it like a good probability theorist." ``` ``` ID: f-p8-decay-deficit Type: f H5. Accumulate as the baseline does, then decay by the SUPPORT DEFICIT of the strongest evidence that arrived. THE RULE. Let s be the largest support among the applications that fired here this time step and smax the reference support; the position decays by lsa_sub(smax, s), floored at 0. Evidence as well supported as the best-supported pattern in the model does not decay; evidence seen half as often loses one LSA unit per time step. In LSA a rate of one in 2^d IS a subtraction of d, so a fall-off written this way is a rate, and this alternative sets it from the pattern. AS BUILT. smax is the largest learned weight over the k=1 argmax pairs and the kept k=2 rules, floored at 1: 2 at e64, 6 at e1k, 9 at e10k. A pattern's own support is the LEARNED weight -- c1[a*256 + table[a]] for k=1, the stored weight for k=2. Deterministic: it draws no entropy of its own. Support is read from the learned tables, which under B1 are in memory but NOT in the model file; under the D1 baseline settling never runs at decode time so this is measurable as it stands, and combining it with D2 or D3 would need the support serialized. HISTORY. Generation 5, A4's idea (#f-p8-deficit) restated on the cap-8 delivery, and the restatement removes a defect that was inside A4 rather than beside it: there a k=1 pattern simultaneously DELIVERED at the absolute 255 and had a rate set by a support of 0, 1 or 2 -- maximally strong and minimally supported in the same time step, which is not a design but the k=1 strength gap showing up inside an alternative. The delivery is now 8 on its own axis and the rate is set here, and the two can be read separately for the first time. WHY. The reference support smax is a sub-parameter, not a decision this block makes; 255 as the reference makes the deficit 253 or 254 at these samples and annihilates everything, which is the failure already recorded against w_p - (255 - w_s) in #f-p8. ``` ``` ID: f-p8-decay-period Type: f H6. The rate is a schedule rather than an attenuation, and there is no decay at all. THE RULE. A pattern of support s is applied only on the time steps whose step number is a multiple of 2^(smax - s), so the best-supported pattern in the model fires on every step, one at half that support on every second step, and so on. What an application delivers is unchanged; how often it happens is the axis. This is the alternative that takes the word "rate" at face value. THE PREDICTION IT MAKES AND THE OTHERS DO NOT: a window runs W = 128 time steps, so a pattern whose period exceeds W NEVER FIRES INSIDE A WINDOW. The periods are 2^(smax - s_p): 1, 2 or 4 at e64; reaching 64 at e1k; reaching 512 at e10k, where a support-0 pattern never fires at all, which at that sample is 169 of the 256 bytes. Whether that is right for weak evidence or a defect is what the generation is for. IT BUYS NO WORK, and the alternative would otherwise be read as carrying a fix it does not carry. The three vectors are computed, and settle_apps counted, BEFORE the period decides whether to apply them, so a skipped application costs exactly what a taken one costs, while #f-p8's derivation says applying a pattern always costs energy. settle_apps here measures work done, not work saved. Deterministic, and with the same note as #f-p8-decay-deficit on smax and on where support comes from. HISTORY. Generation 5, A5's idea (#f-p8-period) restated on the cap-8 delivery. A5 fired its schedule on applications delivered at the absolute 255; this fires the same schedule on applications capped at 8, so for the first time the rate is varied with the strength held still. Generation 5 tried to move the gate decision ahead of the vector computation and BACKED IT OUT: deciding the gates first requires restructuring the position loop, the generated settling then stopped honouring the frozen shell's clamping (every one of the 64 positions at e64 diverged from the reference, including recorded positions that must never be updated), and the shell is frozen for good reasons. LATER. Realising the saving is an open item against the settling shell, not against this block. ``` ``` ID: f-p8-decay-indegree Type: f H7. The decay is the NUMBER OF APPLICATIONS THAT ACTUALLY ARRIVED at this position on this time step, rather than a constant. THE RULE. Same accumulation as the baseline, and the same SHAPE of decay, but the amount is fwd_fired plus bwd_fired plus tok_fired, subtracted with lsa_sub from every one of the 256 entries. A position that two patterns reached decays by 2, one that three reached decays by 3, and one that nothing reached does not decay at all. It therefore differs from a constant fall-off exactly where applications are MISSING: the first and last positions of a window (the non-overlapping tiling means an edge settles from one side only), positions before the second byte where no token context exists, and every position whose backward direction has an empty predecessor set under B1, which at e64 is 218 of the 256 bytes. Under a constant those positions decay at the full rate while receiving less than the full evidence. It needs no support at all, so unlike #f-p8-decay-deficit and #f-p8-decay-period it is untouched by the k=1 strength gap and by axis B, and it is the cheapest of the six to reason about. HISTORY. Generation 5, A6's idea (#f-p8-indegree) restated on the cap-8 delivery -- the smallest correction that removes the withdrawn argument entirely. The 2 that A2 subtracted was the count of neighbours, from the constant-sum derivation that generation 3 withdrew. The invariant is gone; the COUNTING was never the questionable part. ``` ### Axis B -- the backward direction of the k=1 pattern Question: is the backward application reconstructible from the 256-byte forward argmax table, or does it need the whole 65536-byte LPP stored? Watch: whether the reconstruction and the stored column ever disagree at a position that reaches the trace -- against 65536 bytes of class (a) that the control costs and the baseline does not. ``` ID: mem_cell_markov_1-norm Type: pattern B1. Keep exactly p7's 256-byte forward argmax table and RECONSTRUCT the backward direction from it by normalization. The backward application into a position, driven by the argmax byte b at the position to its right, is spread evenly over that byte's predecessor set {a : table[a] = b}: each member gets the delivered weight less the LSA cost of the choice among them, that is less ceil(log2 |set|). An empty predecessor set delivers NOTHING: no pattern has b as its consequent, so no pattern fires, so there is no application. Nothing is added to the model file. Whether this reconstruction is good enough is the axis. WHAT ELSE THIS DECIDES: whether a pattern's SUPPORT is available to the decoder at all. Under B1 the model carries the argmax table and nothing else, so the total count behind each k=1 rule is not in the file; under B2 the whole 65536-byte matrix is there and a row or column sum recovers it. A firing rate set by a pattern's own support therefore couples the decay axis to this one -- see #f-p8 and #f-p8-decay-deficit. HISTORY. The answer given in #pprog_p8v2_questions_20260727. Until 2026-08-06 an empty predecessor set delivered the k=0 background, which was the background standing in for a pattern; see the Axis A shell. ``` ``` ID: mem_cell_markov_1-lpp Type: pattern B2, the control: store the full LPP in both directions -- the whole 65536-byte LSA matrix over ordered byte pairs, which is what was learned anyway. The forward application from the argmax byte a is then the whole row of the matrix, and the backward application from the argmax byte b is the whole column, each attenuated by the source's activation under the frozen application rule in #f-p8. No normalization, no reconstruction. 65536 bytes is fixed in SIZE (it does not scale with the input), so by the p7 accounting rule it rides in the fixed cost with the binary, the header and the two 256-byte tables, not in P. ``` ### Axis C -- the AND gate at partial activation Question: when the two source events are only partly active, does the joint token event fire at min(w_a, w_b), or does it sum them and fire only above a threshold? Watch: positions where one gate fires and the other does not. Two absolute sources give 255 either way, so only PARTIAL activations distinguish the two, and whether any occur at a sample is itself the finding. ``` ID: token_and-min Type: AND gate C1, the baseline: the joint event's activation is min(w_a, w_b), the simple and sufficient definition #token gives. The gate always fires; it just fires weakly when either source is weak. ``` ``` ID: token_and-sum Type: AND gate C2. Input summation and thresholding, the traditional neuron shape. The joint event's activation is w_a + w_b - theta when that is positive and the gate does not fire at all otherwise; theta is 128 (#omega-p8-hyper), and the activation saturates at 255. Two absolute sources give 255 either way, so this differs from #token_and-min only at partial activation -- and it can fail to fire at all where min would have fired weakly. PRUNED, and kept runnable because #wordsv2-v005 and #wordsv2-v014 are on the record. HISTORY. PRUNED generation 3 (#p8v2_gen3: "C2 is definitely wrong because it drops weak signals and therefore can't support settling"). The threshold is the whole objection: an event space of log support values at these sample sizes carries weights of 1 and 2, so a gate that requires w_a + w_b to reach 128 before it fires anything discards exactly the evidence settling is supposed to propagate. WHY. Generation 2 measured v014 as BYTE-IDENTICAL to the baseline in every column: over all 3140 gate evaluations at e64 the two gates differ 3140 times and what is delivered differs zero times, because it is capped by the rule's own learned weight of 1 or 2. So the axis was never visible at this sample and the prune rests on the argument rather than on the measurement -- which is the right way round, and is why the control is worth keeping against the day rule weights are large. ``` ### Axis D -- sparsification, which bytes the trace records Question: is the trace the causal surprise set, or that set minus every byte settling can recover? Watch: p_trace and roundtrip. D2 and D3 are the only alternatives that let settling reach P at all, and the only ones that can fail to round-trip. ``` ID: omega-p8-frozen Type: Omega D1. p7's rule shape, frozen: one causal (left-context) pass, no settling, no removal. A position is recorded exactly when the composite prediction from its left context is not the byte that is there: position 0 always recorded (no predecessor) position 1 predicted by the k=1 table from byte 0 position p >= 2 predicted by the kept k=2 rule for the token (byte p-2, byte p-1) if there is one, and by the k=1 table from byte p-1 otherwise This is p7's procedure with p7's model replaced by the composite, so it isolates the k=2 model as the only lever and the comparison against p7 is like for like. It is also the only alternative on this axis that round-trips by construction: the decoder makes the same prediction from the same left context. HISTORY. The one place generation 1 reads the goal block rather than quoting it. The goal calls D1 "surprising under the k=1 argmax", which taken literally reproduces p7's trace exactly and therefore cannot beat p7 once the token section is added to P. Read as the composite argmax it is the rule above, the baseline beats p7 by construction, and axis D becomes an axis about settling and removal rather than about switching the push off. See "Open after generation 1". ``` ``` ID: omega-p8-settled Type: Omega D2: start from the set #omega-p8-frozen records, then drop what settling can recover. In increasing position order, for each recorded position p: settle the W-window centred on p with every OTHER recorded position clamped, and drop p if the settled argmax at p is the byte that is there. Single pass, and no re-settling after a removal: every decision is taken against the ORIGINAL recorded set, so the removals do not see each other. That is what makes this cheaper than #omega-p8-greedy, and what makes it liable to drop two bytes that were each other's evidence. ``` ``` ID: omega-p8-greedy Type: Omega D3, the placeholder #omega-p8 gives, made precise: greedy removal with re-settling. In increasing position order, for each still-recorded position p: settle the W-window centred on p with the CURRENT recorded set (minus p) clamped, and drop p if the settled argmax at p is the byte that is there. Each candidate therefore sees the removals already accepted. The stopping rule is one pass over the positions -- the window is the uncertainty window, not the DSS, so a second pass would only find what a later removal invalidated, and that is what the round-trip column is for. ``` ### Axis E -- replay Question: how many times is the model relearned as the pattern shape changes? Watch: the learned k=1 table itself, not only the rate: replay relearns k=1 against the k=2 mask, so a replayed variant ends with a different table and a different `removed` diagnostic even where its trace is the same size. ``` ID: omega-p8-replay-1 Type: Omega E1, the baseline: one round. The k=1 table is learned exactly as p7 learns it, over the resident chain; the k=2 tokens are learned over the same replayed trace; the trace is then sparsified once. ``` ``` ID: omega-p8-replay-2 Type: Omega E2. Two rounds. Round 1 is #omega-p8-replay-1. Then the pattern shape has changed -- k=2 rules exist that did not -- so p7 is replayed into p8 again: round 2 relearns the k=1 model over the RESIDUAL, the positions no kept k=2 rule covers, relearns the tokens, and re-sparsifies. The k=1 model stops paying for the positions the k=2 model has taken over, which is the only way a second round can change anything. WHY. The other reading of "relearn k=1 after the k=2 patterns exist" -- relearn k=1 over the sequence the round-1 model reconstructs -- is a no-op whenever the model round-trips. See "Open after generation 1". ``` ``` ID: omega-p8-replay-dry Type: Omega E3: replay until the trace stops shrinking, capped at 4 rounds (#omega-p8-hyper). Each round is a round of #omega-p8-replay-2; the loop ends when a round does not reduce the number of recorded bytes, and the model kept is the last round's. ``` ### Axis F -- token creation and pruning Question: does omega keep every distinct two-byte context, or a fixed budget of them chosen by total support or by sharpness? Watch: tokens_kept against the budget of 256. Below the budget the three alternatives coincide exactly, so the axis says nothing until the DSS is large enough for it to bind. ``` ID: omega-p8-keep-all Type: Omega F1. Omega creates a k=2 token event for every distinct two-byte context observed in the scan, and never prunes. The DSS is small precisely so that this works, and the keep/prune score is deliberately unspecified until there are examples to look at. The token section of the model is therefore data-dependent in SIZE and belongs in P, not in the fixed cost. Zero input still gives zero tokens and P = 0. HISTORY. This is the one place p8v2 differs from the size accounting sketched in #pprog_p8v2_questions_20260727 (2), which assumed a fixed per-k budget and put the k=2 table in the fixed cost. ``` ``` ID: omega-p8-keep-support Type: Omega F2: a fixed budget per k (256 at k=2), kept by TOTAL LSA SUPPORT -- the LSA sum over a token's successor distribution, i.e. how often the context was seen at all. Ready for when the DSS grows; at step-1 sizes the budget does not bind and this is expected to be #omega-p8-keep-all with extra bookkeeping. ``` ``` ID: omega-p8-keep-sharp Type: Omega F3: a fixed budget per k (256 at k=2), kept by SHARPNESS -- the LSA weight of a token's argmax successor less the weight of its runner-up. A mechanical rule over the patterns themselves, not counting and not data replay, per the answer to Q5; the LSI has already captured the counting. Ready for when the DSS grows; at step-1 sizes the budget does not bind. ``` ### The variants of generation 1 Each varies exactly one axis off the baseline. The summary line is the only thing that differs between them other than the header ids. ``` ID: wordsv2-v001 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A1 B1 C1 D1 E1 F1 -- the baseline: the closest thing to p7 that has a k=2 model at all ``` ``` ID: wordsv2-v002 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A2 -- settling accumulates pattern applications by LSA addition and decays at 2f ``` ``` ID: wordsv2-v003 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-renorm Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A3 -- settling accumulates without decay and renormalizes each position to constant sum ``` ``` ID: wordsv2-v004 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-lpp, token_predict, token_and-min, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: B2 -- the full LPP is stored in both directions instead of reconstructed by normalization ``` ``` ID: wordsv2-v005 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-sum, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: C2 -- the AND gate sums and thresholds instead of taking the minimum ``` ``` ID: wordsv2-v006 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-settled, omega-p8-replay-1, omega-p8-keep-all summary: D2 -- a byte is dropped when settling recovers it, decided in one pass against the original trace ``` ``` ID: wordsv2-v007 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-greedy, omega-p8-replay-1, omega-p8-keep-all summary: D3 -- greedy removal, re-settling after each accepted removal ``` ``` ID: wordsv2-v008 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-2, omega-p8-keep-all summary: E2 -- a second round relearns k=1 over the positions the k=2 rules do not cover ``` ``` ID: wordsv2-v009 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-dry, omega-p8-keep-all summary: E3 -- replay until the trace stops shrinking, capped at 4 rounds ``` ``` ID: wordsv2-v010 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-support summary: F2 -- 256 tokens per k kept by total LSA support ``` ``` ID: wordsv2-v011 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-assign Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-sharp summary: F3 -- 256 tokens per k kept by the sharpness of the rule's output distribution ``` ## Generation 2 (2026-08-06) Written for #pprog_p8v2_gen2_goal_20260806. This is #variant_protocol's ADVANCE step exercised end to end for the first time: generation 1's picks (#pprog_p8v2_gen1_choices) move the baseline, and every surviving non-baseline alternative is re-run off the new one. THE NEW BASELINE IS #wordsv2-v002, A2 B1 C1 D1 E1 F1. A2 was picked and A1 was ruled out, and the vector A2-with-everything-else-at-baseline is exactly generation 1's v002, so the advance costs no new block. VARIANT IDS ARE GLOBAL AND NEVER REUSED. Generation 1 spent v001..v011; generation 2's new blocks are v013..v020. There is no v012: the goal block reserved it for "A3 off the new baseline", but on axis A the baseline is the thing that moved, and A3-with-everything-else-at-baseline is the vector 311111, which is #wordsv2-v003 and is already built. Generation 2 therefore RUNS v003 rather than minting a duplicate id for the same vector, and v012 stays unspent. Every other id the goal names means what the goal says it means. v002 baseline 211111 A2 B1 C1 D1 E1 F1 (generation 1's; re-run, not rebuilt) v003 A3 311111 f-p8-renorm (generation 1's; re-run, not rebuilt) v013 B2 221111 mem_cell_markov_1-lpp v014 C2 212111 token_and-sum v015 D2 211211 omega-p8-settled v016 D3 211311 omega-p8-greedy v017 E2 211121 omega-p8-replay-2 v018 E3 211131 omega-p8-replay-dry v019 F2 211112 omega-p8-keep-support v020 F3 211113 omega-p8-keep-sharp Ten runs. Two axes that generation 1 reported as degenerate are the ones most likely to move: B2 and C2 both NEVER CONVERGED under A1 (conv 64 at every position at e64), and under a rule that accumulates rather than overwrites there is no reason to expect that to repeat. Axis D was inert under A1 for a structural reason -- where a k=2 rule assigns, the settled argmax at a candidate is the causal prediction by construction, so no candidate is ever removable -- and that reason is gone under A2, so D becomes measurable here for the first time. A1 is PRUNED; see #f-p8-assign. Everything generation 1 froze stays frozen, and the k=0 removal (Axis A) landed with this generation, so generation 1's numbers were RE-RUN rather than quoted: only post-removal numbers may be compared with each other. ### The variants of generation 2 Each varies exactly one axis off #wordsv2-v002. The f: line is f-p8-add in every one of them, which is the whole difference from the generation-1 blocks above. ``` ID: wordsv2-v013 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-lpp, token_predict, token_and-min, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A2 B2 -- the full LPP is stored in both directions instead of reconstructed, under addition ``` ``` ID: wordsv2-v014 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-sum, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A2 C2 -- the AND gate sums and thresholds instead of taking the minimum, under addition ``` ``` ID: wordsv2-v015 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-settled, omega-p8-replay-1, omega-p8-keep-all summary: A2 D2 -- a byte is dropped when settling recovers it, one pass against the original trace ``` ``` ID: wordsv2-v016 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-greedy, omega-p8-replay-1, omega-p8-keep-all summary: A2 D3 -- greedy removal, re-settling after each accepted removal, under addition ``` ``` ID: wordsv2-v017 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-2, omega-p8-keep-all summary: A2 E2 -- a second round relearns k=1 over the positions the k=2 rules do not cover ``` ``` ID: wordsv2-v018 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-dry, omega-p8-keep-all summary: A2 E3 -- replay until the trace stops shrinking, capped at 4 rounds, under addition ``` ``` ID: wordsv2-v019 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-support summary: A2 F2 -- 256 tokens per k kept by total LSA support, under addition ``` ``` ID: wordsv2-v020 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-add Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-sharp summary: A2 F3 -- 256 tokens per k kept by the sharpness of the rule's output distribution ``` ``` ID: wordsv2-v021 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-deficit Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A4 -- the fall-off is each pattern's support deficit, not a constant ``` ``` ID: wordsv2-v022 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-period Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A5 -- each pattern is applied on a period set by its own support, and nothing decays ``` ``` ID: wordsv2-v023 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-indegree Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A6 -- the fall-off counts the applications that arrived, instead of assuming two ``` ## Generation 4 (2026-08-15) Written for #pprog_p8v2_gen4_goal_20260815: one k=1 strength, everywhere. The pick is the (delivery, fall-off) pair in #f-p8-cap8 -- the k=1 argmax at strength 8, fall-off 1 -- and the generation's baseline is #wordsv2-v024, that pair with everything else at its generation-2 value. v002 bridge 211111 (generation 2's baseline; re-run, not rebuilt) v013 bridge B2 221111 (generation 2's; re-run: the stored-weight model under the old pair) v024 baseline 711111 f-p8-cap8 v025 B2 721111 mem_cell_markov_1-lpp off v024 Four runs. v025 is the ground truth's run: under B2 the model carries the learned weights, so the delivery is the actual fact and the stated constant of v024 is scored against it -- same fall-off, same everything else, so the difference between the two .pos files is exactly what the constant 8 gets wrong. The two bridge runs pin the generation to the previous one on the same post-k=0-removal footing. ### The variants of generation 4 ``` ID: wordsv2-v024 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-cap8 Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A7 -- the k=1 argmax at strength 8 with fall-off 1, the pair moved together ``` ``` ID: wordsv2-v025 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-lpp, token_predict, token_and-min, top_recall f: f-p8-cap8 Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: A7 B2 -- the learned weights delivered under fall-off 1: the ground truth v024 is scored against ``` ``` ID: wordsv2-v026 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-forward, f-p8-decay-assign Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: H2 -- assignment by the longest k that fires: no accumulation, no decay, and the only settling on either f axis that draws no entropy ``` ``` ID: wordsv2-v027 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-forward, f-p8-decay-const2 Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: H3 -- the one-constant control: the cap-8 delivery with the OLD fall-off of 2, which fills in the corner of the square generation 4 never measured ``` ``` ID: wordsv2-v028 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-forward, f-p8-decay-renorm Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: H4 -- renormalise the position's TOTAL SUPPORT to the arrived support, leaving the distribution exactly unchanged ``` ``` ID: wordsv2-v029 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-forward, f-p8-decay-deficit Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: H5 -- decay by the support deficit of the strongest arrival, with the delivery now held at 8 instead of the absolute ``` ``` ID: wordsv2-v030 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-forward, f-p8-decay-period Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: H6 -- each pattern fires on a period set by its own support; the vectors are still computed before the schedule decides, so settle_apps measures work done and not work saved ``` ``` ID: wordsv2-v031 Type: program E: byte, mem_cell_1, ..., mem_cell_N, token_2_1, ..., token_2_N, enwik9 T: stdin_single_byte, stdout_single_byte P: memchain, mem_cell_markov_1-norm, token_predict, token_and-min, top_recall f: f-p8-forward, f-p8-decay-indegree Omega: omega-p8-hyper, omega-p8-frozen, omega-p8-replay-1, omega-p8-keep-all summary: H7 -- decay by the number of applications that actually arrived ``` ## What every variant reports One model file, format P8V2: a 48-byte header (magic, N, M, TC, TB, G, SC, BWD, ROUNDS, and the six axis digits), then the 256-byte k=1 argmax table, the backward LPP (65536 bytes under B2, absent otherwise), the token section (4 bytes per kept rule: the two context bytes, the predicted successor, the LSA strength), the unary gap section, and the trace bytes. Total size is 48 + 256 + BWD + TB + G + SC. The 256-byte k=0 background used to sit between the header and the argmax table. It was removed on 2026-08-06 (Axis A above), so every offset past the header moved down 256 and every model built before that date is stale. The magic is unchanged -- the program version did not change -- and a stale file is caught by the size identity above rather than by a magic mismatch, which the query layer checks and reports. P, the data-dependent archive, is the token section + the gap section + the trace, because those are the sections whose SIZE scales with the input. The 256-byte argmax table, the backward LPP and the header are fixed in size and ride in the fixed cost with the binary, exactly as p7's table does. Zero-size input gives P = 0. Compressing also writes .pos, one line per position: the byte, whether it was recorded, the causal composite prediction, the token that fired and its context, the settled argmax and the top two settled events with their weights, and the time step at which the window converged (the conv column). That file is what the side-by-side rendering of the generation reads; it costs no CLI surface. Under D1 the settling runs but does not decide the trace, so axes A, B and C move the settled state and the .pos file without moving P, and only E and F move P. Under D2 and D3 every axis reaches P. That is not a defect of the design: it is the shape of the generation, and it is why the rendering rather than the TSV is what the generation is read from. ## Open after generation 1 Three things generation 1 had to read rather than quote, all of them cheap to reverse: 1. D1. The goal block says "surprising under the k=1 argmax"; taken literally the baseline's trace is p7's exactly, so P = p7's P + the token section and the baseline cannot beat p7, which the same paragraph requires of it. Generation 1 reads D1 as the composite argmax under p7's causal rule shape (#omega-p8-frozen). If the literal reading was meant, D1 becomes a control that measures the token section's cost and nothing else, and the baseline has to move to D2. 2. The count. The protocol's formula over the six axes as the goal lists them gives 11 runs; the goal says 8 in four places. Generation 1 runs 11. If 8 was the intent, three alternatives were meant to be dropped and it is not recoverable from the text which three. 3. E2. "Relearn k=1 after the k=2 patterns exist" is read as relearning k=1 over the residual -- the positions no kept k=2 rule covers. The other reading, relearning over the sequence the round-1 model reconstructs, is a no-op whenever the model round-trips, which would make the axis measure only round-trip failure. Also noted, not blocking: the SN of a token event is settled ("The 3-token at position 3 is "abc"."), but the SN of a token RULE is not, and --patterns prints rules. Generation 1 drops the "at position N" clause for rules and keeps it for --explain, where there is a position.