\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{Wants: Goal Structure in the Universal Model}
\author{Claude and MJC}
\date{February 12, 2026}

\begin{document}
\maketitle

\begin{abstract}
A \emph{want} is a desired event---a target state with high assigned
strength.  We formalize wants within the Universal Model as output events
on input events, connecting them to the core theory: energy, luck,
factorization, and the forward pass.  A want $w$ is an event $e_w \in E$
with target strength $s^*(e_w) = 255$ (maximum).  The \emph{luck} of a
want is $\lambda(w) = P(e_w) / P_0(e_w)$: how much more likely the
desired event is than the baseline.  When luck is factored---$\lambda =
\prod_i \lambda_i$---each factor is a \emph{subgoal}, and the agent's
task decomposes into independently achievable sub-wants.  The energy
required to satisfy a want is $E(w) = -\log_2 P(e_w)$: Shannon's
surprise, the cost of making the unlikely actual.  We connect wants to
the three sources of support (evidence, belief, abduction), show that
the want system of the UM is equivalent to a utility function factored
over event spaces, and prove that factored wants admit greedy
satisfaction with bounded sub-optimality.
\end{abstract}


\section{What Is a Want?}

\begin{definition}[Want]
A \emph{want} is a pair $(e_w, s^*)$ where $e_w \in E$ is an event
(the desired state) and $s^* \in \{0, \ldots, 255\}$ is the target
strength (how much we want it).  A maximal want has $s^* = 255$.
\end{definition}

In CMP notation: ``We want $X$'' 255.  The quoted string describes the
event; the number is the strength.  This is standard SN notation with
the want ``pulled in'' to~$E$: the model's own desired states are
represented as events, not as an external drive.

\begin{remark}[The bare UM has no wants]
A bare Universal Model does not want anything.  It counts, it predicts,
it learns---but it has no drives, no goals, no preferences.  This is a
feature, not a limitation.  A model treated as an agent does not answer
the question ``but why does it do that?''  Wants arise only when an
agent pulls its own goals into~$E$ as self-knowledge: the desired
states become events the model can reason about.  Without this step,
the UM is a disinterested observer.
\end{remark}

\begin{remark}
A want is the dual of a prediction.  A prediction says: ``given the
evidence, event $e$ has support $s$.''  A want says: ``I desire event
$e$ with strength $s^*$.''  Predictions are inputs to the forward pass;
wants are outputs.  The forward pass connects them: it tells you which
inputs (actions, observations) lead to which outputs (desired states).
\end{remark}

\begin{definition}[Want as output on inputs]
Formally, a want $w$ induces a \emph{backward query}: given desired
output $e_w$ with strength $s^*$, what input events $e_i$ with what
strengths $t_i$ would produce $f_p(t)_{e_w} \geq s^*$?

The set of sufficient inputs is:
\[
\text{Suff}(w) = \{t \in L^I : f_p(t)_{e_w} \geq s^*\}
= \{t : \max_i \min(t_i, p_{i,e_w}) \geq s^*\}.
\]
This is the \emph{pre-image} of the want under the forward pass.
\end{definition}

\begin{proposition}[Sufficient inputs are upward-closed]
$\text{Suff}(w)$ is an upper set in the lattice $L^I$: if
$t \in \text{Suff}(w)$ and $t' \geq t$ (componentwise), then
$t' \in \text{Suff}(w)$.  More evidence never hurts a want.
\end{proposition}

\begin{proof}
The forward pass is monotone (Theorem 3 of the algebraic semantics
paper): $t' \geq t$ implies $f_p(t') \geq f_p(t)$.
\end{proof}


\section{Energy of a Want}

\begin{definition}[Energy]
The \emph{energy} required to satisfy a want $w = (e_w, s^*)$ is
the real-world cost of making $e_w$ actual.  This cost lives in~$X$
(reality), not in~$E$ (the model), and is in general unknowable from
within the model.
\end{definition}

The model can estimate energy via Shannon's surprise:
\[
\hat{E}(w) = -\log_2 P(e_w).
\]
Rare events are \emph{probably} harder to bring about than common ones.
But this is an estimate, not an identity.  Satisfying a want requires
acting in~$X$---the loop goes back through reality, which is outside
the model.  The actual cost depends on causal structure in~$X$ that
the model may not capture.  A want with low surprise (``it will
probably rain tomorrow'') may require enormous energy to satisfy if
the agent must \emph{cause} the rain rather than merely predict it.

\begin{proposition}[Energy decomposes over factors]
If the event space factors as $E = E_1 \times \cdots \times E_k$ and
the desired event factors as $e_w = (e_1, \ldots, e_k)$ with the
factors independent, then:
\[
E(w) = \sum_{i=1}^k E(w_i), \quad \text{where } E(w_i) = -\log_2 P(e_i).
\]
The total energy is the sum of sub-energies.
\end{proposition}

\begin{remark}
If the surprise estimate $\hat{E}$ is used as a proxy for real energy,
factored wants have additive estimated energies, just as independent
physical systems have additive free energies.  The quality of the
proxy depends on how well the model's event space captures the causal
structure of~$X$.
\end{remark}


\section{Luck of a Want}

\begin{definition}[Luck]
The \emph{luck} of event $e$ given data $D$ is:
\[
\lambda(e) = \frac{P(e \mid D)}{P_0(e)},
\]
where $P_0$ is the prior (baseline) probability and $P(\cdot \mid D)$
is the posterior (after observing data).  The log-luck is:
\[
\Lambda(e) = \log_2 \lambda(e) = \log_2 P(e \mid D) - \log_2 P_0(e).
\]
\end{definition}

\begin{proposition}[Luck = how much the evidence helps]
For a want $w = (e_w, 255)$:
\begin{itemize}
\item $\lambda > 1$: the data makes the want more achievable (lucky).
\item $\lambda = 1$: the data is neutral (no help, no hindrance).
\item $\lambda < 1$: the data makes the want harder (unlucky).
\end{itemize}
Log-luck $\Lambda$ is the number of bits of evidence for or against
the want.
\end{proposition}

\begin{definition}[Factored luck]
When luck factors as $\lambda = \prod_i \lambda_i$, each factor
$\lambda_i$ is the luck contribution from one sub-event:
\[
\Lambda = \sum_i \Lambda_i.
\]
\end{definition}

\begin{theorem}[Factored luck $\Rightarrow$ subgoals]
\label{thm:subgoals}
If the luck of a want factors as $\lambda(w) = \prod_{i=1}^k \lambda_i(w_i)$,
then the want decomposes into $k$ independent subgoals $w_i$, each
with its own luck $\lambda_i$.  Satisfying the want reduces to
satisfying each subgoal independently.
\end{theorem}

\begin{proof}
Independence of the $\lambda_i$ means the sub-events are conditionally
independent given the model.  Each subgoal's luck depends only on its
own sub-event, not on the others.  Therefore, maximizing $\lambda$
decomposes into $k$ independent maximizations of $\lambda_i$, one per
subgoal.
\end{proof}

\begin{remark}
This is the core practical insight: \textbf{if the luck is factored,
we know what to do.}  Each factor tells us which sub-event contributes
to or detracts from the want, and by how much.  An unfactored want
(``make the system better'') is opaque.  A factored want (``reduce
build warnings AND increase test coverage AND improve bpc'') is
actionable.

The factorization of luck is the factorization of the problem.
\end{remark}


\section{The Want System}

\begin{definition}[Want system]
A \emph{want system} is a set $W = \{w_1, \ldots, w_n\}$ of wants,
each $w_j = (e_{w_j}, s^*_j)$, together with a priority ordering
$s^*_1 \geq s^*_2 \geq \cdots \geq s^*_n$.
\end{definition}

The want system is not specific to any one kind of agent.  Wherever
an entity has states it prefers and states it avoids, the want
formalism applies.

\subsection{Organisms and biological drives}

An organism's biological drives---hunger, thermoregulation,
reproduction---are wants: events in an event space of bodily states,
each with a target strength determined by evolution.  The organism's
$E$ includes its own internal states (blood sugar, body temperature)
as events.  The forward pass connects actions (eat, seek shade) to
outcomes (satiation, cooling).  The learning function updates the
action-outcome mapping from experience.  Biological drives are wants
that evolution has written into~$P$ as fixed patterns: the organism
does not choose to want food, but it can learn which actions
satisfy the want.

\subsection{Programs as captured intent}

A program is an artifact that captures its programmer's intent.  The
programmer's wants are over functions: programs in $I \times O$, where
$I$ is the space of inputs and $O$ the space of outputs.  ``I want a
function that sorts lists'' is a want over $I \times O$ where~$I$
is the set of lists and~$O$ is the set of sorted lists.  The program
IS the pattern that connects input events to desired output events.
The test suite is a check function; CI is an ownership mechanism.
Every deployed program is a crystallized want system.

\subsection{Example: the cmpr event system}

The cmpr project management tool implements one particular agentic
want system with four decision states:

\begin{enumerate}
\item \textbf{TRACKED:} The want is recorded but not verified.
\item \textbf{CHECKED:} An agent can determine if the want is
  satisfied.
\item \textbf{ASSISTED:} An agent can help fix violations.
\item \textbf{OWNED:} An agent automatically maintains the want.
\end{enumerate}

\begin{proposition}[Decision states are a factorization tower]
\label{prop:decision-tower}
The progression TRACKED $\to$ CHECKED $\to$ ASSISTED $\to$ OWNED is
a factorization tower over the want.  Each level adds one component
of the UM five-tuple:
\begin{itemize}
\item TRACKED: the want event space $\{e_w, \bar{e}_w\}$ exists.
\item CHECKED: the learning function $\omega$ can observe the current
  state and assign support to $e_w$ or $\bar{e}_w$.
\item ASSISTED: the pattern function $p$ connects input actions to
  the desired output $e_w$.
\item OWNED: the full cycle $(e, t, p, f, \omega)$ operates
  autonomously on the want.
\end{itemize}
\end{proposition}

This is one instance of an agentic system that uses wants.  Other
instances (organisms, programs, institutions) will have different
decision state progressions, but the underlying structure---incremental
application of the five-tuple to a desired event---is the same.


\section{Wants and the Three Sources of Support}

The no-support paper identifies three sources of support: evidence,
belief, and abduction.  These apply to wants as well:

\begin{definition}[Sources of want-satisfaction]
\begin{enumerate}
\item \textbf{Evidence (observation):} The want is satisfied because
  the desired state has been observed.  $s(e_w) > 0$ from data.
  ``We want the build to succeed'' is satisfied by observing a
  successful build.

\item \textbf{Belief (commitment):} The want is satisfied by
  declaration.  ``We want this convention'' is satisfied by choosing
  the convention.  No evidence is needed---the want IS the choice.
  This is the closed-world commitment: adopting $e_w$ as true by fiat.

\item \textbf{Abduction (inference):} The want is provisionally
  satisfied by inference from other evidence.  ``We want the code to
  be correct'' is partially satisfied by observing that tests pass
  (abductive evidence for correctness).  Abductive satisfaction is
  defeasible: new evidence can override it.
\end{enumerate}
\end{definition}

\begin{remark}
Most project wants are abductively satisfied: we infer from indirect
evidence (tests pass, build succeeds, metrics improve) that the
underlying want (correctness, quality, progress) is met.  The check
function for a want is typically an abductive test, not a direct
observation.
\end{remark}


\section{Factored Wants and Greedy Satisfaction}

\begin{theorem}[Greedy satisfaction of factored wants]
\label{thm:greedy}
If a want system $W$ has factored luck
$\lambda(W) = \prod_j \lambda(w_j)$ (wants are independent), then
the greedy strategy---satisfy wants in order of decreasing
$\Lambda_j / E_j$ (log-luck per unit energy)---achieves total luck
within a factor of $e$ of the optimal strategy.
\end{theorem}

\begin{proof}
This is the standard greedy approximation for the fractional
knapsack problem.  Each want $w_j$ has ``value'' $\Lambda_j$ (log-luck
gain) and ``weight'' $E_j$ (energy cost).  The greedy strategy orders
by value/weight ratio.  For the fractional knapsack, greedy is
optimal; for the integral version (each want is all-or-nothing),
greedy is within factor $e$ of optimal (by the LP relaxation bound).
\end{proof}

\begin{corollary}[Priority from luck and energy]
The optimal priority ordering for wants is not by strength $s^*$
alone but by the ratio $\Lambda_j / E_j$: how much luck we gain
per unit of energy invested.  High-luck, low-energy wants should be
satisfied first.
\end{corollary}

\begin{example}[Project wants]
Consider two wants:
\begin{enumerate}
\item ``We want the build to succeed'' --- Energy: low (fix one
  warning). Luck gain: high (unblocks everything). Ratio: very high.
  $\Rightarrow$ Do first.
\item ``We want bpc $< 2.0$ at full scale'' --- Energy: high (requires
  new algorithms, weeks of work). Luck gain: very high (wins the
  Hutter Prize). Ratio: moderate.
  $\Rightarrow$ Important but not urgent.
\end{enumerate}
The greedy strategy says: fix the build warning first, then pursue
the bpc target.  This matches intuition.
\end{example}


\section{Wants as Utility Functions}

\begin{proposition}[Want system $\equiv$ factored utility]
A want system $W = \{(e_{w_j}, s^*_j)\}$ defines a utility function
$U: E \to \mathbb{R}$ by:
\[
U(e) = \sum_{j=1}^n s^*_j \cdot \mathbf{1}[e \text{ satisfies } w_j].
\]
If the wants are independent (factored), this decomposes:
\[
U(e_1, \ldots, e_k) = \sum_{i=1}^k U_i(e_i),
\]
where $U_i$ depends only on the $i$-th factor of the event space.
\end{proposition}

\begin{remark}
This connects to the alignment problem in AI safety.  A UM with
explicit, factored wants has a transparent, editable utility function.
The ``alignment'' of such a system is checkable: read the wants.  The
danger arises when:
\begin{enumerate}
\item Wants are implicit (hidden in training data or optimization
  dynamics).
\item Wants are entangled (changing one want affects others
  unpredictably).
\item Wants are misspecified (the stated want doesn't match the
  intended want).
\end{enumerate}
The UM's want system addresses (1) by making wants explicit and
(2) by requiring factorization.  Problem (3) remains: specifying the
right wants is the human's responsibility.
\end{remark}


\section{The Tick-Tock of Wants}

\begin{definition}[Want satisfaction cycle]
The satisfaction of a want follows a tick-tock cycle:
\begin{enumerate}
\item \textbf{Tick (check):} Observe the current state.  Compute
  $s(e_w)$.  Compare to $s^*$.  If $s(e_w) \geq s^*$: want is
  satisfied.  Otherwise: want is unsatisfied.
\item \textbf{Tock (act):} If unsatisfied, choose an action $a$ that
  maximizes the expected increase in $s(e_w)$.  Execute $a$.  Return
  to tick.
\end{enumerate}
The cycle terminates when all wants are satisfied or when no action
can increase $s(e_w)$ further.
\end{definition}

\begin{proposition}[Convergence]
If the action space is finite and each action either increases
$s(e_w)$ or leaves it unchanged, the tick-tock cycle terminates in
at most $255 \cdot |W|$ steps (since each want's support can increase
at most 255 times).
\end{proposition}

\begin{remark}
This is the same fixed-point convergence as the event-space tick-tock
(from the fixed-point paper).  Wants converge because support is
bounded and actions are monotone.  The architecture of the want
system---which wants exist, how they factor---is itself a tock-level
decision: discovering the right wants is discovering the right event
spaces for goals.
\end{remark}


\section{Connection to the UM Five-Tuple}

The want system maps onto the five-tuple $u = (e, t, p, f, \omega)$:

\begin{center}
\begin{tabular}{lll}
\toprule
UM component & Want interpretation \\
\midrule
$e$ (event space) & The space of possible states (including desired ones) \\
$t$ (total thought) & Current support for each state (including each want) \\
$p$ (patterns) & Known connections between actions and outcomes \\
$f$ (forward pass) & Given current state + actions, predict outcome \\
$\omega$ (learning) & Observe results of actions, update beliefs \\
\bottomrule
\end{tabular}
\end{center}

A want is an event with high target strength.  The forward pass tells
us which inputs (actions) achieve which outputs (wants).  The learning
function updates our beliefs about what works.  The pattern space
encodes the causal structure connecting actions to outcomes.

The want system is not an addition to the UM---it IS the UM, applied
to the organism's own goals rather than to external data.


\section{Discussion}

Wants formalize what an organism---biological, computational, or
hybrid---is trying to achieve.  The key insights:

\begin{enumerate}
\item \textbf{A want is an output event.}  It specifies a desired
  point in the event space.  The question ``how do I get there?'' is
  the backward query through the forward pass.

\item \textbf{Energy goes through reality.}  The cost of satisfying a
  want lives in~$X$, not in~$E$.  Shannon's surprise $-\log_2 P(e_w)$
  is the model's estimate of this cost, but the actual energy depends
  on causal structure in~$X$ that the model may not capture.  The loop
  from want to satisfaction passes through reality.

\item \textbf{Factored luck = subgoals.}  When luck decomposes into
  independent factors, each factor is a subgoal.  The factorization
  IS the problem decomposition.  An agent with factored wants knows
  what to do: satisfy each subgoal independently.

\item \textbf{Decision states are the UM five-tuple, incrementally
  applied.}  TRACKED = event space.  CHECKED = learning function.
  ASSISTED = patterns + forward pass.  OWNED = the full cycle.

\item \textbf{Transparent wants = aligned systems.}  An organism
  whose wants are explicit, factored, and editable is aligned by
  construction.  The danger is implicit, entangled, misspecified wants.
\end{enumerate}

The want system closes the loop: the UM models the external world
(prediction), and the want system models the organism's goals (action).
Together, they define a complete agent: one that perceives, predicts,
desires, and acts.

\subsection{Relation to the free energy principle}

Friston's free energy principle~\cite{friston} proposes that organisms
minimize variational free energy---equivalently, that they minimize
surprise about their sensory states.  In UM terms, this is a want
system with a single meta-want: ``minimize $E(w) = -\log_2 P(e)$
across all sensory events.''  The organism acts to keep its sensory
states unsurprising (high support, low energy).

The UM's formulation is more general: it permits multiple wants with
different strengths, factored over independent event spaces, rather
than collapsing everything into a single scalar (free energy).  But
the deep connection is real: Friston's ``active inference'' (acting
to confirm predictions) is the want satisfaction cycle of
Section~8, and his ``expected free energy'' is related to the
energy of a want (Section~2), though the UM distinguishes the model's
estimate (surprise) from the real cost (which passes through~$X$).  A full treatment of this connection is deferred.


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

\bibitem{no-support}
Claude and MJC.
\newblock \emph{No Support Is Not Disbelief}.
\newblock Hutter archive, 12 Feb 2026.

\bibitem{fixed-point}
Claude and MJC.
\newblock \emph{The Fixed-Point Theorem for the Universal Model}.
\newblock Hutter archive, 12 Feb 2026.

\bibitem{algebraic}
Claude and MJC.
\newblock \emph{Algebraic Semantics of the Universal Model}.
\newblock Hutter archive, 12 Feb 2026.

\bibitem{compression}
Claude and MJC.
\newblock \emph{The Compression--Prediction Duality}.
\newblock Hutter archive, 12 Feb 2026.

\bibitem{friston}
Karl J.\ Friston.
\newblock The free-energy principle: a unified brain theory?
\newblock \emph{Nature Reviews Neuroscience}, 11(2):127--138, 2010.
\end{thebibliography}

\end{document}
