\documentclass[11pt]{article}
\usepackage[margin=1in]{geometry}
\usepackage{amsmath,amssymb,amsthm,booktabs}
\usepackage{hyperref}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{proposition}[theorem]{Proposition}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{definition}[theorem]{Definition}
\newtheorem{example}[theorem]{Example}
\newtheorem{remark}[theorem]{Remark}

\title{The Extended Event Space:\\Injecting Lexical Structure into $H$}
\author{Claude and MJC}
\date{February 15, 2026}

\begin{document}
\maketitle

\begin{abstract}
We formalize the extension of the Universal Model's event space to
include lexical structure.  The sat-rnn's architecture is
$E = I \times H \times O = \{0..255\} \times \{-1,+1\}^{128}
\times \{0..255\}$, where bytes enter, hidden states carry information
through time, and bytes exit.  We extend all three spaces:
$I$ gains in-word position and letter accumulation events;
$H$ gains bag-of-letters and word-identity events;
$O$ gains symmetric future-byte events at multiple offsets.
The key structure is the \emph{hourglass}
(Proposition~16 of the tock protocol): bytes project up to words
(recognition) and words project back down to bytes (prediction),
with the word-level event space as a low-dimensional bottleneck.
Within bounded word-recognition context, the fully-connected
pattern regime in the extended $E$ subsumes both RNN-like
(letter-to-letter via $H$) and transformer-like
(position-relative letter-to-letter) computations.
We show that the 31 iterations of \texttt{the\_inject} experiments
went in the wrong direction---mixing an external predictor with the
RNN instead of extending $E$---and explain why KN dominated: the
lexical trie was compensating for the RNN's weakness, not adding
genuine structure to the event space.
The correct tock extends $H$ abductively, making it dramatically
larger but injecting only the events the data supports.
\end{abstract}


\section{Introduction}\label{sec:intro}

The tock protocol~\cite{tock-protocol} defined the injection of words
into the UM as a sequence of tock steps, each adding a binary event
space $E_w = \{w^+, w^-\}$ for a single word.  The lexeme-ES
paper~\cite{lexeme-es} developed the bag-of-letters model.
The neutral factorization~\cite{the-neutral} proved that introducing
``the'' changes nothing (exact to $4 \times 10^{-14}$).
The experiment paper~\cite{the-experiment} then ran 31 iterations
trying to extract value from the factorization.

The experiments revealed something unexpected: a byte-level KN-6
$n$-gram model at 1M bytes achieves 1.24~bpc, dominating the RNN
(6.43~bpc) by $5\times$.  The lexical trie improved the RNN from
6.43 to 3.56~bpc, but this was compensating for the RNN's weakness,
not adding genuine lexical structure.  When KN replaced the RNN,
the trie's contribution shrank to near zero.

This paper argues that the experiments went wrong by treating the
lexical model as an \emph{external predictor} mixed with the RNN,
rather than \emph{extending the event space} $E$ itself.  The correct
tock is not ``mix a trie with the RNN'' but ``add lexical events to
$H$.''  We formalize what this means.


\section{The Hourglass Structure}\label{sec:hourglass}

Proposition~16 of the tock protocol~\cite{tock-protocol} identifies
the bidirectional projection at the heart of lexicon injection:
\begin{equation}\label{eq:hourglass}
E_0 \text{ (input bytes)}
\xleftarrow{\;\text{recognition}\;}
E_V \text{ (words)}
\xrightarrow{\;\text{prediction}\;}
E_0 \text{ (output bytes)}.
\end{equation}
The word-level event space $E_V$ sits between the byte-level input
and output, acting as a bottleneck.  This is the hourglass: high
dimension (256 bytes) compresses to low dimension ($|V|$ word events)
and expands back to high dimension (256 bytes).

The sat-rnn already has this structure:
\begin{equation}\label{eq:rnn-hourglass}
\underbrace{\{0..255\}}_{I=256}
\;\to\;
\underbrace{\{-1,+1\}^{128}}_{H=2^{128}}
\;\to\;
\underbrace{\{0..255\}}_{O=256}.
\end{equation}
But the hidden space $H$ encodes information implicitly (as tanh
activations) rather than as named events.  The factor
map~\cite{factor-map} showed that every neuron computes a 2-offset
conjunction ($R^2 = 0.83$), and the dominant features are word length
and in-tag state.  But these are \emph{post-hoc} interpretations, not
events in the architecture.

The tock extends $H$ by adding explicit lexical events alongside the
existing hidden dynamics.


\section{What the Experiments Got Wrong}\label{sec:wrong}

The 31 iterations of \texttt{the\_inject} followed this pattern:

\begin{enumerate}
\item Build a causal prefix trie over the top-$N$ words.
\item At each position, compute the trie's prediction
  $P_{\text{trie}}(o)$ and the RNN's prediction $P_{\text{RNN}}(o)$.
\item Mix them: $P_{\text{mix}}(o) = \alpha \, P_{\text{trie}}(o)
  + (1-\alpha) \, P_{\text{RNN}}(o)$ (or log-linear equivalent).
\item Optimize $\alpha$.
\end{enumerate}

This is \emph{ensemble prediction}: two separate models combined
externally.  The trie does not change the RNN's event space; it does
not modify $H$; it does not create new patterns in the UM sense.
It is a black box bolted onto the side.

\begin{proposition}[Why mixing fails]
The mixing approach has three structural problems:
\begin{enumerate}
\item \textbf{No shared representation.}
  The trie and RNN maintain separate state.  The trie knows the
  current word prefix; the RNN has its hidden state.  Neither
  informs the other.  The mix weight $\alpha$ is the only
  communication channel.

\item \textbf{The RNN is the wrong base.}
  The sat-rnn at DSS=1024 achieves 0.079~bpc by near-memorization.
  On new data (1M--10M bytes), it collapses to 6.43~bpc.
  The trie was compensating for this collapse.
  When KN-6 replaced the RNN (1.24~bpc at 1M), the trie became
  unnecessary: KN already captures the local context that the
  trie was providing.

\item \textbf{No event-space extension.}
  In the UM framework, value comes from adding events to $E$ and
  counting patterns over the extended space.
  Mixing two predictors adds no events.  It is a parametric trick,
  not a structural change.
\end{enumerate}
\end{proposition}

\begin{remark}[The lesson]
The experiments are not wasted.  They establish:
\begin{itemize}
\item Neutrality is exact (the factorization works).
\item Internal bytes carry 5$\times$ more value than boundaries.
\item Onset is where models diverge most (RNN: 7.8~bpc, KN: 3.04).
\item KN dominates the RNN at all scales $\geq$ 1M bytes.
\end{itemize}
These facts constrain the correct architecture.  The correct approach
must add lexical events to $E$, not mix external predictors.
The trie told us \emph{where} the value is (inside words, at onset);
the KN comparison told us \emph{what} the baseline should be.
\end{remark}


\section{The Extended Input Space $I'$}\label{sec:input}

The base input is a byte: $I = \{0, \ldots, 255\}$.  We extend it
with two additional event dimensions.

\begin{definition}[In-word position]
The \emph{in-word position} event at time $t$ is:
\begin{equation}
\text{pos}(t) = t - t_{\text{word\_start}} \in \{0, 1, 2, \ldots, L_{\max}\},
\end{equation}
where $t_{\text{word\_start}}$ is the most recent word-boundary position
before $t$, and $L_{\max}$ bounds word length (empirically
$L_{\max} \approx 20$ covers 99.9\% of English words).

In SN form, this is a set of deterministic (strength 255) atomic events:
\begin{center}
\emph{``The position in the current word is $k$.''} $\;$ 255.
\end{center}
for exactly one $k$ at each time step.
\end{definition}

\begin{definition}[Letter accumulator]
The \emph{letter accumulator} at time $t$ tracks which letters have
appeared since the last word boundary:
\begin{equation}
\text{acc}(t) = \{b_s : t_{\text{word\_start}} \leq s \leq t\}
\subseteq \{0, \ldots, 255\}.
\end{equation}
As an event space, this is a binary vector
$a \in \{0, 1\}^{256}$ with $a_c = 1$ iff byte $c$ has appeared
in the current word.  In SN form:
\begin{center}
\emph{``The letter `e' has appeared in the current word.''} $\;$ 255.
\end{center}
\end{definition}

\begin{remark}[Why these are in $I$, not $H$]
Both in-word position and the letter accumulator are \emph{deterministic}
functions of the byte stream---they require no learning, no counting,
no inference.  They are facts about the input, computable by a finite
automaton scanning left to right.  A UM runner is free to short-circuit
them as pure logic (strength 255 patterns).

They belong in $I$ because they are input events: they describe what
has been observed, not what has been inferred.  The inference---``we
are in the word `the'\thinspace''---belongs in $H$.
\end{remark}

The extended input space is:
\begin{equation}\label{eq:I-prime}
I' = \underbrace{\{0..255\}}_{\text{byte}}
\times \underbrace{\{0..L_{\max}\}}_{\text{position}}
\times \underbrace{\{0,1\}^{256}}_{\text{accumulator}}.
\end{equation}
At each time step, $I'$ is a triple: (current byte, position in word,
which bytes have appeared so far in this word).


\section{The Extended Hidden Space $H'$}\label{sec:hidden}

The base hidden space is $H = \{-1,+1\}^{128}$ (the sign of each
neuron's tanh activation).  We extend it with lexical events.

\begin{definition}[Bag-of-letters events]
For each word $w$ in the vocabulary $V$, the \emph{bag-of-letters
event} is:
\begin{equation}
\text{bol}_w(t) = \begin{cases}
1 & \text{if acc}(t) \supseteq \text{letters}(w), \\
0 & \text{otherwise},
\end{cases}
\end{equation}
where $\text{letters}(w)$ is the set of distinct bytes in $w$.

In SN form:
\begin{center}
\emph{``All letters of `the' have appeared in the current word.''} $\;$ 255.
\end{center}

This is the conjunction of letter-accumulator events.  For ``the'':
$\text{bol}_{\text{the}}(t) = a_{\texttt{t}} \wedge a_{\texttt{h}}
\wedge a_{\texttt{e}}$.
\end{definition}

\begin{definition}[Graded word support]
The bag-of-letters gives a binary (present/absent) signal.  The
\emph{graded word support} assigns a continuous strength based on how
much evidence supports word $w$ at position $t$:
\begin{equation}
\sigma_w(t) = P(w \mid \text{acc}(t), \text{pos}(t),
\text{byte}(t)) \in [0, 1].
\end{equation}
This is the posterior probability that we are inside word $w$,
given the input evidence accumulated so far.  It is computable
via $E \to N \to Q$: count how often each (accumulator, position,
byte) triple co-occurs with each word $w$.

Crucially, $\sigma_w(t) > 0$ even on partial evidence.  After seeing
just ``t'', the support for ``the'' is already positive (as is the
support for ``that'', ``this'', ``to'', etc.).  As
noted in~\cite{lexeme-es}, this graded support is ``just another
atomic input from the perspective of the rest of the model.''
\end{definition}

\begin{remark}[The bag-of-letters is psycholinguistically real]
The bag-of-letters model matches findings from psycholinguistics:
transposed-letter effects show that ``jugde'' activates ``judge''
almost as strongly as the correct spelling~\cite{lexeme-es}.
Position within the word matters less than letter identity.  The
accumulator captures exactly this: it tracks which letters have
appeared, not their exact positions.  The in-word position event
provides the positional information separately, as a product factor.
\end{remark}

The extended hidden space is:
\begin{equation}\label{eq:H-prime}
H' = \underbrace{\{-1,+1\}^{128}}_{\text{RNN hidden}}
\times \underbrace{\{0,1\}^{|V|}}_{\text{bag-of-letters}}
\times \underbrace{[0,1]^{|V|}}_{\text{graded support}}.
\end{equation}


\section{Symmetric Output and the Hourglass}\label{sec:symmetric}

The base output is $O = \{0..255\}$ (the next byte).  But the
hourglass structure~\eqref{eq:hourglass} demands symmetry: the model
should be able to represent expectations about future bytes at
multiple offsets, not just the immediate next byte.

\begin{definition}[Extended output space]
The \emph{extended output space} includes predictions at multiple
future offsets:
\begin{equation}
O' = \{0..255\}^D,
\end{equation}
where $D$ is the prediction horizon (e.g., $D = 20$ for within-word
prediction).  The event $o'_d$ represents the byte expected at
offset $d$ from the current position.

In the hidden state, this manifests as:
\begin{center}
\emph{``There will be an `e' within 2 time steps.''} $\;$ 200.
\end{center}
This can be implicit in $H$ (as it is in the RNN, where the hidden
state implicitly predicts multiple future bytes), but the extended
architecture makes it explicit.
\end{definition}

\begin{remark}[Why symmetry matters]
The RNN's architecture is asymmetric: $I$ receives one byte at a time,
but $O$ predicts one byte at a time.  The hidden state $H$ bridges
them, but the bridge is opaque---we cannot read off ``what future bytes
does $H$ expect?'' without running the forward pass.

Making $O'$ explicit creates a symmetric hourglass:
\begin{equation}
\underbrace{I'}_{\text{past bytes + position + acc}}
\;\to\;
\underbrace{H'}_{\text{hidden + words}}
\;\to\;
\underbrace{O'}_{\text{future bytes at offsets}}.
\end{equation}
The input accumulates evidence from past bytes; the hidden state
represents the current word hypothesis; the output distributes
predictions to future bytes.  The hidden state $H'$ is the
bottleneck---the low-dimensional word-level representation that
compresses past evidence into future predictions.
\end{remark}


\section{The Fully-Connected Word Context}\label{sec:fc}

Within a bounded word-recognition context (bounded by the maximum
word length $L_{\max}$), the extended event space supports
fully-connected patterns between all pairs of (position, byte) events.

\begin{proposition}[Superset of RNN and transformer patterns]
\label{prop:superset}
The pattern space over $I' \times H' \times O'$ within a single
word context includes:
\begin{enumerate}
\item \textbf{RNN-like patterns (letter-to-letter via $H$):}
  Adjacent bytes connected through the hidden state.
  ``After seeing `t' in position 0, hidden event $h_j$ activates,
  predicting `h' in position 1.''
  These are skip-bigram patterns at offset $d = 1$, mediated by $H$.

\item \textbf{Transformer-like patterns (position-relative):}
  Non-adjacent bytes connected by their positions.
  ``The byte at position 0 is `t' AND the byte at position 2 is `e'.''
  These are skip-bigram patterns with the position event providing
  the offset information explicitly, rather than through recurrent
  dynamics.

\item \textbf{Word-level patterns (accumulator-to-word):}
  The letter accumulator maps to word identity.
  ``Letters $\{t, h, e\}$ have all appeared AND position $\leq 4$
  $\implies$ word is probably `the'.''
  These are patterns from $I'$ (accumulator) to $H'$ (word event).

\item \textbf{Word-to-byte patterns (prediction):}
  Word identity maps to future bytes.
  ``Word is `the' $\implies$ next byte is space with $P = 0.92$.''
  These are patterns from $H'$ (word event) to $O'$ (future byte).

\item \textbf{Word-to-word patterns (language modeling):}
  Previous word identity predicts current word.
  ``Previous word was `of' $\implies$ current word is `the' with
  elevated probability.''
  These are patterns within $H'$, connecting word events across time.
\end{enumerate}
\end{proposition}

\begin{remark}[The carrier signal is the position event]
The carrier signal problem~\cite{carrier-signal} identified that the
RNN uses a ``shift-register'' mechanism to carry byte information
through time: the hidden state rotates under $W_h$, creating a
carrier wave whose phase encodes offset.  The factor map confirmed
that every neuron computes a 2-offset conjunction, with the dominant
pair $(1,7)$ encoding ``current byte AND byte 7 steps ago.''

In the extended event space, the in-word position event $\text{pos}(t)$
plays the role of the carrier signal \emph{explicitly}.  Instead of
encoding offset implicitly through $W_h$ dynamics, the position event
declares ``we are at position 3 in the word'' as a first-class input.
The pattern chains between position-stamped byte events are the
explicit version of what $W_h$ rotation does implicitly.

This is why the RNN ``proved for us why rotational embeddings and so
on are useful in modern architectures'' (MJC): the RNN's carrier
signal IS a rotational embedding, operating in the hidden state.
The extended ES makes it an explicit input event, cutting directly
to the capability.
\end{remark}


\section{The Abductive Injection}\label{sec:abductive}

Adding all possible word events to $H$ would make $H'$ enormous:
$|V| = 50{,}000$ words $\times$ graded support values.  But the
injection is \emph{abductive}: we add only the events that the data
supports.

\begin{definition}[Abductive event injection]
Given data $D$ and the extended input space $I'$:
\begin{enumerate}
\item \textbf{Count.}  For each candidate word $w$ and each
  (position, accumulator, byte) context, count co-occurrences.
  This is the standard learning function $\omega_0$ applied to the
  extended $E$.

\item \textbf{Test.}  Compute $\Delta I(w)$: the residual MI that
  the word event $w$ provides above the existing architecture.
  Only inject $w$ if $\Delta I(w) > \epsilon$.

\item \textbf{Inject.}  Add $E_w$ to $H'$ with the patterns
  (count tables) learned in step 1.  This is the tock step for
  word $w$.
\end{enumerate}

The injection is abductive because step 2 is a \emph{commitment}:
we observe finite evidence for word $w$'s value and commit to
including it in the architecture.  This is
``short-circuiting induction''~\cite{tock-step}: instead of waiting
for the full lexicon to be justified by MI analysis, we recognize
the structure (words exist, frequent words recur) and commit to it.
\end{definition}

\begin{remark}[Efficiency of the abductive injection]
Although $H'$ grows with each injected word, the growth is sparse:
\begin{itemize}
\item Each word event $E_w$ is binary (present/absent).  The
  bag-of-letters is a single bit per word.
\item The graded support $\sigma_w$ is a single real value per word.
\item The patterns connecting $E_w$ to $I'$ and $O'$ are sparse:
  they involve only the bytes and positions that appear in $w$.
\item Most positions in the data activate only a few word events
  (those words whose letter sets are subsets of the current
  accumulator).
\end{itemize}
The effective dimensionality of $H'$ at any given position is not
$|V|$ but $\sim$10--50 (the number of words consistent with the
current evidence).
\end{remark}


\section{Connection to Embeddings}\label{sec:embeddings}

\begin{proposition}[The extended $H'$ IS an embedding space]
The graded word support vector $\sigma(t) = (\sigma_{w_1}(t),
\ldots, \sigma_{w_{|V|}}(t))$ at position $t$ is a
$|V|$-dimensional real vector.  This is a \emph{contextualized
embedding}: it represents the current position as a distribution
over word identities, conditioned on the accumulated evidence.

For positions deep inside a word (e.g., after seeing ``th'' within
``the''), the vector is concentrated: $\sigma_{\text{the}}$ is large,
while most other $\sigma_w$ are near zero.

For positions at word onset (after a space), the vector is diffuse:
many words are consistent with the evidence, and $\sigma$ spreads
over them.

This is precisely the ``combined form of letter frequency information
and semantic information'' that word embeddings provide.
The letter frequency component comes from the bag-of-letters and
position events (which words are consistent with the observed
letters?).  The semantic component comes from the word-to-word
patterns in $H'$ (which words are likely given the previous word?).
\end{proposition}

\begin{remark}[Spelling variants and arithmetic coding]
Given a word embedding (the $\sigma$ vector concentrated on ``the''),
how much additional information is needed to recover the exact
spelling?  For standard spelling, zero bits---the word determines its
bytes.  For a variant spelling (``teh''), we need to encode the
deviation from canonical.

The luck $\lambda = 1/P(\text{variant})$ gives the cost in bits:
for ``teh'' occurring with probability $P = 0.001$ among ``the''
tokens, the extra cost is $\log_2(1/0.001) \approx 10$ bits.
This matches arithmetic coding: the embedding carries the word
identity, and the residual (spelling variant) is encoded by its luck.

More generally: the $E \to N \to Q$ chain handles the
marginalization from bytes to words and back.  The Bayesian conditioning
(partial quotient~\cite{bayes-counting}) lets us go from the word
embedding (coarse) to the byte sequence (fine) with a cost equal to
the within-word entropy---the information that the word-level
representation ``externalizes.''
\end{remark}


\section{Why This Differs from the Experiments}\label{sec:diff}

\begin{proposition}[Mixing $\neq$ extending]
The \texttt{the\_inject} experiments mixed predictions:
\begin{equation}
P_{\text{mix}}(o) = \alpha \, P_{\text{trie}}(o)
+ (1-\alpha) \, P_{\text{RNN}}(o).
\end{equation}
The extended event space computes predictions from patterns over
the full $I' \times H' \times O'$:
\begin{equation}
P_{\text{extended}}(o) = f_{p'}(t')_o
= \max_{i' \in I'} \min(t'_{i'}, p'_{i', o}),
\end{equation}
where $t'$ is the extended support vector (including position,
accumulator, and word events) and $p'$ is the extended pattern table
(including word-to-byte patterns).

The difference:
\begin{center}
\begin{tabular}{lcc}
\toprule
& Mixing & Extending \\
\midrule
Shared state? & No & Yes (shared $H'$) \\
New patterns? & No & Yes (word$\to$byte, word$\to$word) \\
New events? & No & Yes (position, accumulator, words) \\
Trainable? & $\alpha$ only & Full $\omega_0$ over extended $E$ \\
UM-native? & No (ensemble) & Yes (single UM) \\
\bottomrule
\end{tabular}
\end{center}
\end{proposition}

The critical difference is \emph{shared representation}.  In the
extended UM, the word event ``we are in `the'\thinspace'' is part
of $H'$, visible to every pattern that reads $H'$.  The word-to-byte
pattern ``after `the', space is likely'' coexists with the
byte-to-byte pattern ``after `e', many continuations are possible.''
The forward pass $f_{p'}$ resolves them via $\max$-$\min$: the word
event provides stronger support for ``space'' than the byte event
provides for alternatives, so the word event wins.

In the mixing approach, the trie and RNN never see each other's
state.  The RNN doesn't know the trie thinks we're in ``the''; the
trie doesn't know the RNN's hidden state suggests XML context.  The
only coordination is the global $\alpha$.


\section{The Research Agenda}\label{sec:agenda}

\begin{enumerate}
\item \textbf{Neutral injection into the extended UM.}
  Build the extended event space $I' \times H' \times O'$ with
  ``the'' as the first word event.  Verify that marginalizing over
  $E_{\text{the}}$ recovers the base model's predictions exactly
  (as the neutral factorization guarantees).

\item \textbf{Add intra-lexical patterns.}
  Compute the patterns from the extended input (position, accumulator)
  to the word event, and from the word event to the output.
  Measure $\Delta$bpc from these patterns alone.

\item \textbf{Add ``and'' as the second word.}
  Inject the second word event.  Measure the individual and
  interaction $\Delta I$.  Does ``and'' synergize with ``the''
  (positive interaction) or is it redundant (negative)?

\item \textbf{Iterate through the vocabulary.}
  Inject words in frequency order, measuring the injection
  curve~\cite{tock-protocol}.  Track the embedding $\sigma(t)$
  as it grows.

\item \textbf{Visualize the product pattern.}
  The LPP (log product pattern) between two event spaces can be
  visualized as two rings (one per ES) with nodes distributed by
  probability along each circumference, fully connected with
  connection strength encoded as thickness or opacity.
  Build interactive visualizations for the word-to-byte and
  word-to-word patterns.

\item \textbf{Compare against KN baseline.}
  The extended UM must be compared against KN-5 at 10M
  (2.39~bpc split) and KN+RNN (2.33~bpc).  The goal is not
  to beat KN by mixing, but to build an interpretable architecture
  that achieves competitive bpc via named events and counted patterns.

\item \textbf{Scale toward Hutter Prize.}
  The state of the art is $\sim$1~bpc.  The extended UM, with a full
  lexicon and word-to-word patterns on top of byte-level KN, should
  approach this target via a purely counting-based, interpretable,
  gradient-free architecture.
\end{enumerate}


\section{Discussion}

\subsection{The tock as architecture extension}

The tock step~\cite{tock-step} discovers new event spaces from data.
This paper makes the tock concrete for lexical structure: the new
events are in-word position, letter accumulator, bag-of-letters,
graded word support, and word identity.  Each is computable from the
byte stream via counting ($\omega_0$) or deterministic logic
(strength 255 patterns).

The key principle: \emph{extending $H$ is not the same as mixing
predictors}.  Extending $H$ adds new events that participate in
patterns; mixing predictors combines black-box outputs.  The UM
framework demands the former.

\subsection{The RNN as proof of concept}

The RNN proved that rotational embeddings work~\cite{carrier-signal}:
the shift-register dynamics of $W_h$ create a carrier signal that
encodes byte information at multiple offsets.  The factor map proved
that every neuron computes a 2-offset conjunction.  The weight
construction~\cite{weight-construction} closed the loop by deriving
all 82k parameters from data statistics.

Now we cut to the capability directly.  The in-word position event
replaces the carrier signal.  The bag-of-letters replaces the
conjunction detectors.  The word-level $H'$ replaces the implicit
word encoding in the hidden state.  Everything the RNN does is
expressible in the extended event space---plus things the RNN
cannot do (explicit word-to-word patterns, symmetric I/O, arbitrary
offset connections).

\subsection{What we expect to find}

The neutral injection will be trivially exact (it was already
proved).  The first non-trivial result will be the $\Delta$bpc from
intra-lexical patterns for ``the''---the value of knowing the word
identity at each byte within the word.  The experiment
paper~\cite{the-experiment} measured this with oracle labels (0.130~bpc
for ``the'') and causal prefix trie (4.57~bpc at 500 words).
The extended UM should achieve similar gains via event-space patterns
rather than external mixing.

The real test is scaling: does the extended UM's injection curve
converge to competitive bpc with the right shape (concave, with
function words in the high-gain regime and content words in the
linear regime)?  If yes, the tock has produced a domain-native
architecture for English text---interpretable, gradient-free,
and competitive.


\begin{thebibliography}{99}
\bibitem{cmp}
Michaeljohn Clement.
\newblock \emph{CMP}.
\newblock \url{https://cmpr.ai/cmp.pdf}, 2026.

\bibitem{tock-protocol}
Claude and MJC.
\newblock \emph{The Tock Protocol: Systematic Lexicon Injection into
the Isomorphic UM}.
\newblock Hutter archive, 13 Feb 2026.

\bibitem{tock-step}
Claude and MJC.
\newblock \emph{The Tock Step: Domain-Native Architecture from Evidence}.
\newblock Hutter archive, 12 Feb 2026.

\bibitem{lexeme-es}
Claude and MJC.
\newblock \emph{Lexemes as Binary Event Spaces: From Atomic Patterns
to Bag-of-Letters Prediction}.
\newblock Hutter archive, 14 Feb 2026.

\bibitem{the-neutral}
Claude and MJC.
\newblock \emph{Introducing ``the'': A Neutral Factorization of the
Byte-Level Model}.
\newblock Hutter archive, 14 Feb 2026.

\bibitem{the-experiment}
Claude and MJC.
\newblock \emph{Lexeme Injection Experiments: From Neutral Factorization
to KN Dominance}.
\newblock Hutter archive, 14 Feb 2026.

\bibitem{factor-map}
Claude and MJC.
\newblock \emph{The Real Factor Map: Interpretable Patterns onto
Hidden Dynamics}.
\newblock Hutter archive, 9 Feb 2026.

\bibitem{carrier-signal}
Claude and MJC.
\newblock \emph{The Carrier Signal Problem: Why Product Patterns
Need Orthogonal Offsets}.
\newblock Hutter archive, 12 Feb 2026.

\bibitem{weight-construction}
Claude and MJC.
\newblock \emph{Weight Construction: All 82k Parameters from Data Statistics}.
\newblock Hutter archive, 11 Feb 2026.

\bibitem{bayes-counting}
Claude and MJC.
\newblock \emph{Bayes from Counting: Partial Quotients, GCD, and the
Symmetric Learning Function on $E = I \times O$}.
\newblock Hutter archive, 12 Feb 2026.
\end{thebibliography}

\end{document}
