\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}
\newtheorem{protocol}[theorem]{Protocol}

\title{The Tock Protocol:\\Systematic Lexicon Injection into the Isomorphic UM}
\author{Claude and MJC}
\date{February 13, 2026}

\begin{document}
\maketitle

\begin{abstract}
We design a protocol for systematically injecting lexical structure
into the isomorphic Universal Model (the doubled-E UM that exactly
matches the sat-rnn at 0.079~bpc on $\text{DSS}=1024$).
The procedure: add a single word---say ``the''---as a new event in the
event space, measure the resulting changes to count tables, pattern
structure, and prediction quality, then iterate.
Each word addition is a concrete tock step: it introduces
$E_{k+1}$ (a new binary event space: \emph{in-word} vs.\ \emph{not-in-word})
plus maps connecting it to the existing byte-level architecture.
Building up from one word to the full lexicon, we obtain a frequency-ordered
injection sequence where each step's MI gain is measurable and the
cumulative effect traces a curve from byte-level prediction to
word-level prediction.
The protocol makes the tock step constructive and empirically testable:
every claim about lexical structure becomes a measurable delta in bpc.
\end{abstract}


\section{Introduction}

The tock step~\cite{tock-step} discovers new event spaces from data.
The weight construction~\cite{weight-construction} showed that all 82k
parameters of the sat-rnn can be derived from data statistics.
But both are \emph{retrospective}: they analyze what a trained model
already knows.  Neither constructs the model \emph{forward} from first
principles.

This paper designs the forward protocol.  Start with the raw byte-level
UM ($E_0 = \{0, \ldots, 255\}$, unigram prediction, $\sim$5~bpc).
Execute a sequence of tock steps, each adding one word to the event
space.  Track the bpc after each addition.  The result is a constructive
proof that lexical knowledge reduces prediction error, with the exact
contribution of each word quantified.

The key insight: a word is not an opaque token.  A word is a
\emph{pattern}---a specific sequence of bytes that recurs with specific
statistics.  Adding ``the'' to the UM means:
\begin{enumerate}
\item Recognizing the byte sequence $[116, 104, 101]$ (\texttt{t-h-e})
  as a recurrent pattern,
\item Creating a binary event space $E_{\text{the}} = \{1, 0\}$
  (currently in ``the'' vs.\ not),
\item Computing the conditional statistics: what predicts ``the''
  (preceding space, punctuation, sentence start) and what ``the''
  predicts (space followed by a noun-class byte distribution),
\item Measuring the MI gain: how much better can we predict the
  output byte when we know whether we're inside ``the''?
\end{enumerate}

This is exactly a tock step in the sense of~\cite{tock-step}:
$E_{k+1} = E_{\text{the}}$, with maps from the byte-level context
to $E_{\text{the}}$ (recognition) and from $E_{\text{the}}$ to the
output (prediction).


\section{Setup: The Starting Point}

\begin{definition}[Base UM]
The \emph{base UM} is the byte-level Universal Model with:
\begin{itemize}
\item Event space $E_0 = \{0, \ldots, 255\}$ (bytes).
\item Context: the previous $k$ bytes at offsets $d_1, \ldots, d_k$
  (the skip-$k$-gram input space).
\item Count table: $c(i, o) = |\{t : \text{context}_t = i, d_t = o\}|$.
\item Forward pass: $f_p(t)_o = \max_i \min(t_i, p_{io})$.
\end{itemize}
At order 1 (bigram), the base UM achieves 2.05~bpc on DSS=1024.
At order 12 (contiguous 12-gram), it achieves 0.067~bpc~\cite{pattern-chain}.
The sat-rnn achieves 0.079~bpc.
\end{definition}

\begin{definition}[Isomorphic UM (doubled-E)]
The \emph{isomorphic UM} is the doubled-E construction that exactly
reproduces the sat-rnn's predictions at 0.079~bpc by translating
the RNN's $\tanh$ activations and softmax output into UM support
values~\cite{doubled-e}.  This is our reference model: any structural
change must be compared against this baseline.
\end{definition}

\begin{remark}[Why start from the isomorphic UM?]
Starting from the isomorphic UM rather than a raw byte model lets us
measure the \emph{marginal} contribution of lexical knowledge.  The
isomorphic UM already captures everything the RNN knows (offset
conjunctions, character classes, word boundaries).  Adding ``the'' on
top of this tells us: how much does explicit word identity contribute
\emph{beyond} what character-level patterns already provide?
\end{remark}


\section{Protocol Step 1: Injecting a Single Word}\label{sec:single}

\begin{protocol}[Single word injection]
\label{proto:single}
To inject word $w$ (e.g., $w = \texttt{the}$) into the UM:

\medskip\noindent
\textbf{Phase A: Recognition (input map).}
\begin{enumerate}
\item Define the \emph{word detector}: a finite automaton that reads
  the byte stream and outputs a binary signal
  $E_w(t) \in \{1, 0\}$ indicating whether position $t$ is
  inside an occurrence of $w$ (preceded and followed by a word
  boundary: space, punctuation, or start/end of text).

\item For ``the'': $E_{\text{the}}(t) = 1$ iff
  $d_{t-3} \in \{\texttt{' '}, \ldots\}$ and
  $d_{t-2} = \texttt{'t'}$ and
  $d_{t-1} = \texttt{'h'}$ and
  $d_t = \texttt{'e'}$ and
  $d_{t+1} \in \{\texttt{' '}, \ldots\}$.
  This fires at the last byte of each occurrence.

\item Compute the \emph{recognition map} $\rho_w : E_0^k \to E_w$
  from the byte-level context to the word event.  This is a
  deterministic function: given the context bytes, either $w$ matches
  or it doesn't.
\end{enumerate}

\medskip\noindent
\textbf{Phase B: Conditional statistics (count tables).}
\begin{enumerate}
\setcounter{enumi}{3}
\item Partition the dataset into positions where $E_w = 1$ (inside $w$)
  and $E_w = 0$ (outside $w$).

\item For each partition, compute the output byte distribution:
  \begin{align}
  P(o \mid E_w = 1) &= \frac{c(E_w{=}1, o)}{c(E_w{=}1)}, \\
  P(o \mid E_w = 0) &= \frac{c(E_w{=}0, o)}{c(E_w{=}0)}.
  \end{align}

\item Compute the conditional entropy:
  \begin{equation}
  H(O \mid E_w) = P(E_w{=}1) \cdot H(O \mid E_w{=}1)
    + P(E_w{=}0) \cdot H(O \mid E_w{=}0).
  \end{equation}
\end{enumerate}

\medskip\noindent
\textbf{Phase C: MI gain measurement.}
\begin{enumerate}
\setcounter{enumi}{6}
\item The MI contributed by $E_w$ (above the existing model) is:
  \begin{equation}
  \Delta I(w) = H(O \mid \mathcal{A}_k) - H(O \mid \mathcal{A}_k, E_w),
  \end{equation}
  the reduction in output uncertainty from knowing whether we're
  inside $w$, given everything the existing model already knows.

\item The bpc improvement:
  \begin{equation}
  \Delta \text{bpc}(w) = \text{bpc}(\mathcal{A}_k) - \text{bpc}(\mathcal{A}_k \cup \{E_w\}).
  \end{equation}
\end{enumerate}

\medskip\noindent
\textbf{Phase D: Structural analysis.}
\begin{enumerate}
\setcounter{enumi}{8}
\item Record the new patterns created by $E_w$:
  \begin{itemize}
  \item Input patterns: which byte contexts predict $E_w = 1$?
    (These are the word's \emph{triggers}.)
  \item Output patterns: what does $E_w = 1$ predict about the
    next byte?  (This is the word's \emph{continuation distribution}.)
  \item Cross-patterns: how does $E_w$ interact with existing event
    spaces?  (E.g., does ``the'' correlate with the in-tag state?
    With word length?)
  \end{itemize}
\end{enumerate}
\end{protocol}


\subsection{Expected Results for ``the''}

``The'' is the most frequent word in English, comprising roughly
7\% of all word tokens and $\sim$3.5\% of all bytes in typical text.
In enwik9 (Wikipedia XML), the frequency may differ due to markup.

\begin{example}[Predictions for ``the'']
\label{ex:the}
On DSS=1024:
\begin{enumerate}
\item $P(E_{\text{the}} = 1) \approx 0.02$--$0.04$ (``the'' is
  $\sim$3 bytes out of 1024, occurring $\sim$7--13 times).

\item $H(O \mid E_{\text{the}} = 1)$: very low.  Inside ``the'',
  the next byte is deterministic:
  after \texttt{t} $\to$ \texttt{h} (certainty),
  after \texttt{h} $\to$ \texttt{e} (certainty),
  after \texttt{e} $\to$ \texttt{' '} (high probability, with some
  mass on \texttt{'r'} for ``there/their/then/them'', \texttt{'m'}
  for ``them'', etc.).

  Wait---this is where it gets interesting.  The word detector fires
  only on exact ``the'' (with word boundaries), so after the final
  \texttt{e}, the next byte is \texttt{' '} with very high
  probability ($>$90\%?), because ``the'' at a word boundary
  is followed by a space.

\item $\Delta I(\text{the})$: the MI gain depends on how much the
  isomorphic UM already knows.  The sat-rnn at 0.079~bpc already
  captures most character-level predictability.  The residual gain
  from knowing ``this is `the'\thinspace'' is:
  \begin{itemize}
  \item The certainty of \texttt{h} after \texttt{t}-in-``the''
    vs.\ \texttt{t}-in-general.  The RNN probably already captures
    this via the bigram pattern.
  \item The word-boundary prediction after \texttt{e}-in-``the''.
    This is where word identity helps: after \texttt{e} in general,
    many continuations are possible; after \texttt{e} in ``the'',
    only a space (plus rare cases like ``the\textbackslash n'').
  \end{itemize}
  Expected $\Delta I$: small but nonzero, perhaps 0.001--0.01~bpc.
\end{enumerate}
\end{example}

\begin{remark}[The marginal contribution paradox]
The marginal contribution of ``the'' may be tiny because the
character-level model already predicts its bytes well.  The bigram
\texttt{t}$\to$\texttt{h} and \texttt{h}$\to$\texttt{e} are
high-probability transitions regardless of word identity.

But this is exactly the point.  The tock protocol measures the
\emph{residual} contribution of word identity above character
patterns.  If the residual is small, that's informative: it means
the character-level model is already capturing most of what
word-level knowledge provides.

If the residual is large, that's even more informative: it means
word identity carries information \emph{beyond} character patterns,
pointing to specific structural features (word-final predictions,
syntactic role, semantic context) that character patterns miss.
\end{remark}


\section{Protocol Step 2: The Injection Sequence}

\begin{definition}[Frequency-ordered injection]
Order the vocabulary $V = \{w_1, w_2, \ldots, w_M\}$ by frequency
in the dataset, with $w_1$ = most frequent (``the''), $w_2$ = second
most frequent (``of'' or ``and''), etc.

The \emph{injection sequence} is:
\begin{equation}
\mathcal{A}_0 \xrightarrow{+w_1} \mathcal{A}_1
\xrightarrow{+w_2} \mathcal{A}_2
\xrightarrow{+w_3} \cdots
\xrightarrow{+w_M} \mathcal{A}_M,
\end{equation}
where $\mathcal{A}_k$ includes word detectors for $w_1, \ldots, w_k$.
\end{definition}

\begin{proposition}[The injection curve]
The injection sequence produces a curve:
\begin{equation}
\text{bpc}(k) = \text{bpc}(\mathcal{A}_0) - \sum_{j=1}^k \Delta\text{bpc}(w_j),
\end{equation}
plotting bpc against number of words injected.

Properties:
\begin{enumerate}
\item \textbf{Monotone decreasing}: each word can only help (or be
  neutral), never hurt prediction.  $\Delta\text{bpc}(w_j) \geq 0$.

\item \textbf{Concave}: high-frequency words contribute more than
  low-frequency words (by coverage), so the curve bends downward.
  The marginal gain decreases as the lexicon grows.

\item \textbf{Bounded}: the curve is bounded below by the entropy
  rate of the source.  At some point, adding more words provides
  negligible gain.

\item \textbf{Frequency vs.\ MI}: the optimal injection order is
  by MI gain, not by raw frequency.  A rare word with highly
  distinctive continuation (e.g., ``xylophone'' $\to$ always
  followed by specific patterns) may contribute more MI per byte
  than a common word with generic continuations.  In practice,
  frequency dominates because high-frequency words are seen in
  more contexts, providing more statistical power.
\end{enumerate}
\end{proposition}


\subsection{Interaction Effects}

\begin{definition}[Word interaction]
The interaction between words $w_a$ and $w_b$ is:
\begin{equation}
\text{interaction}(w_a, w_b) = \Delta I(w_a, w_b) - \Delta I(w_a) - \Delta I(w_b),
\end{equation}
where $\Delta I(w_a, w_b)$ is the MI gain from adding both simultaneously.

Positive interaction: the words together provide more information
than the sum of their individual contributions (synergy).
Negative interaction: the words are redundant (their contributions overlap).
\end{definition}

\begin{example}[Expected interactions]
\begin{itemize}
\item \textbf{``the'' + ``a''}: negative interaction (redundant).
  Both are determiners; knowing one partially predicts the other's
  distribution.  The MI gain from ``a'' given ``the'' is already
  injected is less than the gain from ``a'' alone.

\item \textbf{``the'' + ``of''}: small interaction.
  These words co-occur in ``of the'' but have largely independent
  continuation distributions.

\item \textbf{``$<$'' + ``$>$''}: positive interaction (synergy).
  Knowing both XML delimiters enables tag-state tracking, which
  neither provides alone.  $\Delta I(<, >) > \Delta I(<) + \Delta I(>)$.
\end{itemize}
\end{example}


\section{What Changes When You Add ``the''}

Adding ``the'' to the UM modifies the prediction in specific, measurable
ways.  Here is the anatomy of a single word injection.

\subsection{The Count Table Delta}

\begin{definition}[Count table delta]
Let $c_0(i, o)$ be the base count table (byte bigrams or skip-$k$-grams).
After injecting $w$, the count table becomes:
\begin{equation}
c_1(i, o) = \begin{cases}
c_0(i, o) & \text{if position is outside } w, \\
c_w(i, o) & \text{if position is inside } w,
\end{cases}
\end{equation}
where $c_w$ is the word-conditioned count table.  The delta is:
\begin{equation}
\Delta c(i, o) = c_w(i, o) - c_0(i, o) \cdot P(E_w = 1).
\end{equation}
This is the \emph{excess} counts attributable to knowing the word.
\end{definition}

For ``the'':
\begin{itemize}
\item $\Delta c(\texttt{'t'}, \texttt{'h'})$: positive (the bigram
  \texttt{th} is more common inside ``the'' than in general).
\item $\Delta c(\texttt{'e'}, \texttt{' '})$: positive (after ``the'',
  the next byte is almost always space).
\item $\Delta c(\texttt{'h'}, \texttt{'e'})$: positive (inside ``the'',
  \texttt{h}$\to$\texttt{e} is certain; in general, \texttt{h} has
  many continuations).
\item $\Delta c(\texttt{' '}, \texttt{'t'})$: positive (space-then-t
  often starts ``the'').
\end{itemize}


\subsection{The Pattern Delta}

\begin{definition}[New patterns from word injection]
A word $w$ of length $\ell$ creates:
\begin{enumerate}
\item $\ell - 1$ \emph{internal patterns}: deterministic byte-to-byte
  transitions within the word.  For ``the'':
  $\texttt{t} \to \texttt{h}$ and $\texttt{h} \to \texttt{e}$
  (with certainty, given that we're in ``the'').

\item 1 \emph{entry pattern}: what precedes the word.
  For ``the'': $\texttt{' '} \to \texttt{t}$ (the space-before-the
  pattern, with strength proportional to $P(\text{the} \mid \text{space})$).

\item 1 \emph{exit pattern}: what follows the word.
  For ``the'': $\texttt{e} \to \texttt{' '}$ (the e-followed-by-space
  pattern, with high strength).

\item $O(\ell^2)$ \emph{skip patterns}: connections between
  non-adjacent positions within the word.  For ``the'':
  $\texttt{t} \xrightarrow{d=2} \texttt{e}$ (skip-bigram).
\end{enumerate}
\end{definition}

\begin{remark}[Internal patterns are free]
The internal patterns of a word ($\texttt{t} \to \texttt{h}$,
$\texttt{h} \to \texttt{e}$) are deterministic within the word:
they contribute zero entropy, hence zero bpc cost.  A model that
\emph{knows} it's inside ``the'' predicts the internal bytes for free.

The bpc savings from word injection come entirely from two sources:
\begin{enumerate}
\item \textbf{Entry sharpening}: knowing $w$ helps predict when $w$
  starts (the entry pattern narrows the distribution over ``what
  comes after a space'').
\item \textbf{Exit sharpening}: knowing $w$ helps predict what follows
  $w$ (the exit pattern narrows the distribution over ``what comes
  after the last byte of this word'').
\end{enumerate}
For short, frequent words like ``the'', the exit pattern is where
the money is: the character-level model already handles internal
bytes well, but the word-final continuation is sharpened by word identity.
\end{remark}


\subsection{The Prediction Delta}

\begin{proposition}[Where bpc changes]
The bpc change from injecting $w$ is concentrated at:
\begin{enumerate}
\item \textbf{The exit position} (last byte of $w$): the biggest gain.
  The model now knows that after ``the'' a space is almost certain,
  whereas before it had to consider all continuations of \texttt{e}.

\item \textbf{The entry position} (first byte of $w$): a smaller gain.
  The model now assigns higher probability to \texttt{t} after a
  space in contexts where ``the'' typically occurs.

\item \textbf{Positions outside $w$}: typically zero change.
  The word detector doesn't fire, so the base model is unaffected.
\end{enumerate}
\end{proposition}


\section{The Lexicon as Factorization}

\begin{definition}[Word-level event space]
Given a vocabulary $V = \{w_1, \ldots, w_M\}$, the \emph{word-level
event space} is:
\begin{equation}
E_V = \{w_1, w_2, \ldots, w_M, \texttt{OOV}\},
\end{equation}
where $\texttt{OOV}$ (out-of-vocabulary) captures all byte sequences
not matching any word in $V$.

The word detector produces the map
$\rho : E_0^* \to E_V$
assigning each position in the byte stream to a word event
(or OOV).
\end{definition}

\begin{proposition}[The lexicon is a quotient]
The map $\rho : E_0^* \to E_V$ is a quotient map in the sense of
the factorization tower~\cite{tock-step}.  It sends sequences of
bytes (fine-grained events) to word labels (coarse-grained events),
discarding internal byte structure.

The factorization tower for text becomes:
\begin{equation}
E_0 \text{ (bytes)} \xleftarrow{\text{recognition}} E_V \text{ (words)}
\xrightarrow{\text{prediction}} E_0 \text{ (output bytes)}.
\end{equation}
The word-level ES sits \emph{between} the byte-level input and
output, acting as a bottleneck that compresses the context into
a word identity.  This is the tock step's product: a new
intermediate event space.
\end{proposition}

\begin{remark}[Lexicon injection $\neq$ tokenization]
Tokenization (BPE, WordPiece, etc.) replaces the byte sequence with
a token sequence, discarding byte-level access.  Lexicon injection
\emph{adds} word-level events \emph{alongside} byte-level events,
preserving full access to both levels.

This is the factorization tower's product factorization:
$E = E_0 \times E_V$, not the sum factorization
$E_0 \twoheadrightarrow E_V$.
The model can use word identity when it helps and byte identity when
it doesn't, without needing to backtrack through a quotient.
\end{remark}


\section{Building Up: From One Word to the Full Lexicon}

\begin{protocol}[Systematic lexicon construction]
\label{proto:lexicon}
\medskip\noindent
\textbf{Stage 0: Baseline.}
Run the isomorphic UM (doubled-E) on the dataset.
Record bpc at each position.
Identify the positions with highest loss (most surprising bytes).

\medskip\noindent
\textbf{Stage 1: Function words (top 20).}
Inject the 20 most frequent words: the, of, and, in, a, to, was,
is, for, on, that, with, as, it, by, from, are, at, an, or.
These are short, high-frequency, and syntactically predictable.
Expected: small individual $\Delta$bpc, but collectively they cover
$\sim$25\% of word tokens.

Measure after each injection:
\begin{itemize}
\item Cumulative bpc.
\item Position-specific bpc changes (which bytes got easier?).
\item Interaction effects between injected words.
\end{itemize}

\medskip\noindent
\textbf{Stage 2: Content words (top 100--1000).}
Inject content words in frequency order.  These are longer, more
variable, and carry more semantic load.  Expected: larger per-word
$\Delta$bpc (longer words $\to$ more exit-pattern sharpening)
but lower coverage per word.

\medskip\noindent
\textbf{Stage 3: Morphological families.}
Instead of injecting ``run'', ``runs'', ``running'', ``ran'' as four
separate words, inject the \emph{stem} ``run'' plus morphological
suffixes as a product factorization:
$E_{\text{run}} \times E_{\text{suffix}} = \{(\text{run}, \emptyset),
(\text{run}, \text{s}), (\text{run}, \text{ning}), (\text{run}, \text{past})\}$.

This tests whether morphological structure provides MI beyond raw
word identity.

\medskip\noindent
\textbf{Stage 4: Saturation.}
Continue injecting words until $\Delta\text{bpc}(w_k) < \epsilon$
for threshold $\epsilon$.  Record the saturation point: how many
words are needed before additional words contribute negligibly?

Expected saturation: $\sim$5k--20k words for English text.
Zipf's law predicts that a small vocabulary covers most tokens.
\end{protocol}


\section{The Measurement Framework}

\begin{definition}[Word-level diagnostics]
For each injected word $w$, record:
\begin{enumerate}
\item \textbf{Coverage}: $P(E_w = 1)$ = fraction of positions inside $w$.
\item \textbf{Marginal MI}: $\Delta I(w)$ = MI gain from $E_w$ alone.
\item \textbf{Conditional MI}: $\Delta I(w \mid \mathcal{A}_k)$ = MI gain
  given the existing architecture.
\item \textbf{Exit entropy}: $H(O \mid E_w{=}1, \text{last byte of } w)$
  = how predictable is the byte after $w$?
\item \textbf{Entry entropy}: $H(E_w{=}1 \mid \text{context})$
  = how predictable is the occurrence of $w$ from context?
\item \textbf{Internal entropy}: $H(\text{bytes within } w \mid E_w{=}1)$
  = should be $\approx 0$ for known words.
\item \textbf{Pattern count}: how many new patterns does $w$ create?
\item \textbf{Interaction vector}: $\text{interaction}(w, w_j)$ for
  each previously injected word $w_j$.
\end{enumerate}
\end{definition}

\begin{proposition}[The three regimes]
The injection curve has three regimes:
\begin{enumerate}
\item \textbf{High-gain regime} ($k < 20$): function words.
  Each word covers many positions.
  The gain is dominated by exit-pattern sharpening.
  Interactions are negative (function words are redundant with
  each other in their character-level patterns).

\item \textbf{Linear regime} ($20 < k < 5000$): content words.
  Each word covers fewer positions but contributes more MI per
  covered position.  The gain per word is roughly constant
  (proportional to $1/k$ coverage times $O(1)$ MI density).
  Interactions are sparse (content words rarely co-occur in
  the same context window).

\item \textbf{Saturation regime} ($k > 5000$): rare words.
  Coverage per word is tiny.  MI gain is negligible.
  The curve flattens.  Further words add no measurable improvement.
\end{enumerate}
\end{proposition}


\section{Connection to BPE and Subword Tokenization}

\begin{proposition}[BPE as greedy tock by compression]
Byte Pair Encoding constructs a vocabulary by iteratively merging
the most frequent adjacent byte pair.  This is a greedy algorithm
optimizing \emph{compression} (reducing sequence length).

The tock protocol constructs a vocabulary by iteratively adding the
word with highest MI gain.  This optimizes \emph{prediction} (reducing
bpc).

These should converge for large datasets: compression and prediction
are dual (Shannon's source coding theorem).  But they may differ
in ordering for small datasets or for words where frequency and
MI diverge.
\end{proposition}

\begin{remark}[Why the tock protocol is better than BPE]
\begin{enumerate}
\item \textbf{Measurable}: each step's contribution is quantified
  as $\Delta$bpc.  BPE gives no per-merge quality metric.

\item \textbf{Additive}: word events are added alongside bytes,
  not replacing them.  No information is lost.  BPE replaces
  the byte sequence, losing character-level access.

\item \textbf{Interpretable}: each word event has a name, a
  coverage, an MI contribution, and a set of patterns.
  BPE merges are opaque.

\item \textbf{Composable}: words interact through the product
  factorization.  Morphological structure, phrase structure,
  and syntactic roles can all be represented as additional
  event spaces layered on top.  BPE is flat.
\end{enumerate}
\end{remark}


\section{The Experimental Plan}

\begin{protocol}[Concrete experimental steps]
\label{proto:experiment}
\begin{enumerate}
\item \textbf{Implement word detector.}
  A simple finite automaton that scans the byte stream and marks
  positions inside occurrences of a target word (with word-boundary
  constraints).  Input: byte stream + word string.  Output: binary
  mask.

\item \textbf{Implement conditional counting.}
  Partition the count table by the word detector's mask.  Compute
  $P(o \mid E_w = 1)$ and $P(o \mid E_w = 0)$.  Compute MI.

\item \textbf{Run on DSS=1024.}
  Start with the isomorphic UM baseline (0.079~bpc).
  Inject ``the''.  Measure $\Delta$bpc.
  Record the position-specific changes.

\item \textbf{Inject top-20 words one by one.}
  After each injection, record all diagnostics from the measurement
  framework.  Plot the injection curve.

\item \textbf{Inject top-1000 words.}
  Run in batch (inject all, measure cumulative).
  Plot bpc vs.\ vocabulary size.

\item \textbf{Compare with BPE.}
  Run BPE tokenization with vocabularies of size 20, 100, 1000.
  Compare the ``equivalent bpc'' (if we had a perfect word-level
  model with each vocabulary) against the tock protocol's actual bpc.

\item \textbf{Test morphological factorization.}
  Inject stems + suffixes as product ESes for the top-50 verb families.
  Compare against injecting each inflected form separately.
  Does morphological structure provide additional MI?

\item \textbf{Scale to enwik9.}
  Run the full protocol on enwik9 (1B bytes).
  The KN-6i baseline is 1.784~bpc~\cite{kn-scaling}.
  How much does lexicon injection improve this?
\end{enumerate}
\end{protocol}


\section{What We Expect to Learn}

\begin{enumerate}
\item \textbf{The word-level contribution to bpc.}
  How much of the character-level model's remaining error is
  attributable to lacking word identity?  If the gap between
  the character model and the word model is large, word events
  are essential.  If small, character patterns already capture
  most of what words provide.

\item \textbf{The saturation curve.}
  How many words are needed?  Zipf's law suggests a power-law
  curve, with $\sim$80\% of the gain from $\sim$20\% of the vocabulary.
  The saturation point tells us the ``natural'' vocabulary size
  for the data---a quantitative answer to ``how many words does
  this language need?''

\item \textbf{Interaction structure.}
  Which words synergize?  Which are redundant?  The interaction
  matrix reveals the syntactic and semantic structure of the
  vocabulary as seen through the lens of MI.

\item \textbf{Entry vs.\ exit.}
  Is the bpc gain dominated by entry sharpening (predicting when
  a word starts) or exit sharpening (predicting what follows a word)?
  This tells us whether word identity is primarily a recognition
  phenomenon or a prediction phenomenon.

\item \textbf{Morphological value.}
  Does morphological structure (stems + suffixes) provide MI beyond
  raw word identity?  If yes, the tock protocol should prefer
  morphological factorization over flat word injection.
  If no, morphology is a human convenience, not a statistical structure.

\item \textbf{The connection to RNN weights.}
  The weight construction~\cite{weight-construction} built all 82k
  params from skip-bigram statistics.  The lexicon injection adds
  word-level statistics.  Can we construct an improved RNN by
  incorporating these word-level patterns into the weight construction?
  This would close the loop: data $\to$ words $\to$ patterns $\to$
  weights $\to$ predictions.
\end{enumerate}


\section{Discussion}

The tock protocol makes the tock step operational.  Instead of
``discover the next event space'' as an abstract instruction, we have
a concrete procedure: pick a word, build a detector, measure the MI,
record the delta.  Each step is small, reversible, and measurable.

The protocol also answers a foundational question: \emph{what is a word,
computationally?}  A word is a recurrent byte pattern that, when
recognized, sharpens the model's predictions at its boundaries.
A word ``exists'' in the UM sense when its binary event space
($E_w$) provides positive MI above the character-level baseline.
Words that provide zero MI are not ``real words'' from the model's
perspective---they are merely byte sequences that happen to recur
without carrying distinctive predictive information.

This is a precise, falsifiable definition of ``word'' grounded in
information theory, not in linguistic convention.  The tock protocol
can be run on any language, any dataset, any alphabet.  The ``words''
it discovers are the ones that the data supports---the natural
vocabulary of the source.

\medskip

The tock protocol is the first concrete implementation of
architecture-from-evidence for the Universal Model.  Each word
injected is a tock step.  The injection curve is the empirical
signature of the tock step's value.  And the full lexicon, at
saturation, is the domain-native architecture that the data
demands.


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

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

\bibitem{doubled-e}
Claude and MJC.
\newblock \emph{Doubled-E: Exact Float UM Isomorphic to RNN}.
\newblock Hutter archive, 30 Jan 2026.

\bibitem{pattern-chain}
Claude and MJC.
\newblock \emph{Pattern Chains: Explicit $i \to \cdots \to o$ from Data}.
\newblock Hutter archive, 7 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{factor-map}
Claude and MJC.
\newblock \emph{The Real Factor Map}.
\newblock Hutter archive, 9 Feb 2026.

\bibitem{kn-scaling}
Claude and MJC.
\newblock \emph{KN Scaling: Byte-Level KN to 1B}.
\newblock Hutter archive, 12 Feb 2026.

\bibitem{carrier-signal}
Claude and MJC.
\newblock \emph{The Carrier Signal Problem}.
\newblock Hutter archive, 12 Feb 2026.
\end{thebibliography}

\end{document}
