History as Identity - v01.tex

\documentclass[12pt]{article}

% ------------------------------------------------------------
% Page Layout
% ------------------------------------------------------------

\usepackage{geometry}
\geometry{margin=1in}

\usepackage{setspace}
\onehalfspacing

% ------------------------------------------------------------
% Mathematics
% ------------------------------------------------------------

\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{mathtools}
\usepackage{amsthm}

% ------------------------------------------------------------
% Diagrams
% ------------------------------------------------------------

\usepackage{tikz}
\usepackage{tikz-cd}

% ------------------------------------------------------------
% Hyperlinks
% ------------------------------------------------------------

\usepackage{hyperref}
\hypersetup{
  colorlinks=true,
  linkcolor=black,
  citecolor=black,
  urlcolor=blue
}

% ------------------------------------------------------------
% Theorem Environments
% ------------------------------------------------------------

\newtheorem{definition}{Definition}[section]
\newtheorem{theorem}{Theorem}[section]
\newtheorem{proposition}{Proposition}[section]
\newtheorem{remark}{Remark}[section]
\newtheorem{example}{Example}[section]

% ------------------------------------------------------------
% Title
% ------------------------------------------------------------

\title{History as Identity:\\
The Append-Only Algebra of Spherepop}

\author{Flyxion}

\date{\today}

% ------------------------------------------------------------
% Document
% ------------------------------------------------------------

\begin{document}

\maketitle

\begin{abstract}
Spherepop is a computational framework whose defining departure from conventional models lies in its treatment of irreversibility as constitutive rather than incidental. Where standard semantic accounts collapse a computation to its observable output---discarding the path by which that output was reached---Spherepop preserves the ordered sequence of exclusions that produced the outcome and treats that sequence as the primary object. This essay develops the formal structure underlying this commitment. We introduce a minimal state representation consisting of a residual option space and an accumulated commitment history, define three primitive operators---\textsc{Pop}, \textsc{Bind}, and \textsc{Collapse}---and show that the resulting algebra is essentially a free history category whose morphisms are finite sequences of irreversible commitments rather than equivalence classes of traces. The contrast with traced monoidal categories is examined in detail: where the trace operator abstracts over internal computation by collapsing feedback into a fixed-point morphism, Spherepop refuses that identification and elevates the internal path to first-class status. The identity of a Spherepop process is therefore its causal history, not its input-output relation. We argue that this makes Spherepop the natural categorical semantics for systems in which provenance, auditability, and ordered commitment matter---systems whose mathematical structure is precisely that of event-sourced append-only logs.
\end{abstract}

\newpage
\tableofcontents
\newpage

\section{Introduction}

A recurring ambition in the theory of computation is the identification of the minimal mathematical structure required to model a class of phenomena faithfully. For deterministic sequential computation that structure is the Turing machine or equivalently the $\lambda$-calculus; for concurrent interaction it is process algebra or the $\pi$-calculus; for feedback and recursion within monoidal categories it is the traced monoidal category of Joyal, Street, and Verity. In each case the theory achieves its power by deciding what to abstract over and what to preserve. Traces, in particular, achieve their power precisely by abstraction: the trace operator $\mathrm{Tr}^U_{A,B}(f)$ for a morphism $f : A \otimes U \to B \otimes U$ asserts that the precise internal behavior on the ``feedback wire'' $U$ is irrelevant once its effect on the external interface $A \to B$ is determined. The loop is collapsed; what remains is the fixed-point input-output relation.

Spherepop originates from the refusal of precisely this identification. Its central commitment is that the internal path---the ordered sequence of decisions, exclusions, and contextual restrictions that produced an observable state---is not auxiliary information to be discarded once a result is known. It is the result. Two computations that terminate at the same value but follow different causal chains are, in Spherepop's ontology, distinct objects. The identity of a process is its history, not its output.

This essay develops the formal structure that underlies that commitment. Section~\ref{sec:traces} reviews traced monoidal categories and isolates precisely what the trace operator abstracts over. Section~\ref{sec:state} introduces the Spherepop state representation as a pair consisting of a residual option space and an ordered commitment history. Section~\ref{sec:operators} defines the three primitive operators---\textsc{Pop}, \textsc{Bind}, and \textsc{Collapse}---and works through the minimal nontrivial example in detail. Section~\ref{sec:algebra} characterizes the resulting algebra as a free history category and compares its structure to path objects in causal categories. Section~\ref{sec:emergence} shows how apparent cyclic behavior emerges from dense chains of irreversible commitments. Section~\ref{sec:connections} draws connections to event sourcing, version control, and other domains where append-only provenance structures appear naturally.

\section{The Trace Operator and What It Hides}
\label{sec:traces}

Before examining what Spherepop preserves, it is useful to be precise about what the trace operator discards. Let $(\mathcal{C}, \otimes, I)$ be a symmetric monoidal category. Recall the definition.

\begin{definition}[Traced monoidal category]
A \emph{traced symmetric monoidal category} is a symmetric monoidal category $(\mathcal{C}, \otimes, I)$ equipped with a family of functions
\[
\mathrm{Tr}^U_{A,B} : \mathcal{C}(A \otimes U,\, B \otimes U) \;\longrightarrow\; \mathcal{C}(A, B),
\]
one for each triple of objects $A, B, U$, satisfying naturality, dinaturality, vanishing (the trace over $I$ reduces to the identity), and the yanking equation $\mathrm{Tr}^U_{U,U}(\sigma_{U,U}) = \mathrm{id}_U$, where $\sigma$ is the symmetry.
\end{definition}

The informal reading is that a morphism $f : A \otimes U \to B \otimes U$ can be ``looped'' by feeding the $U$-component of its output back into its $U$-component input, yielding a morphism $A \to B$ that captures only the external behavior. The dinaturality condition ensures that the trace is insensitive to the choice of representative for the internal computation: any two morphisms $g : A \otimes U \to B \otimes U$ and $h : A \otimes V \to B \otimes V$ related by a change of the internal type $U \cong V$ in the appropriate sense produce equal traces.

This is a remarkable abstraction, and it is precisely the right one for a wide class of applications. In the semantics of recursive programs, the trace models fixed-point recursion: the loop corresponds to the recursive call, and the external morphism $A \to B$ captures the input-output behavior of the recursion without committing to a particular unrolling. In the geometry of interaction interpretation of linear logic, the trace models cut-elimination, and the internal computation on $U$ corresponds to the steps of proof reduction that are erased once the normal form is reached. In each case the power of the trace comes from the fact that it treats the internal path as a \emph{bureaucratic detail}---real and present during computation, but irrelevant to the mathematical object that results.

Spherepop makes the opposite architectural choice. What the trace treats as bureaucratic detail---the ordered sequence of internal steps---is precisely what Spherepop elevates to the role of identity. To understand why, it is necessary to examine what information is lost when a feedback loop is collapsed.

\begin{remark}
Consider two programs $P_1$ and $P_2$ that both compute the identity function $A \to A$, but where $P_1$ reaches this output after zero recursive calls and $P_2$ reaches it after one thousand recursive calls that happen to cancel. In the traced monoidal semantics both programs denote the same morphism $\mathrm{id}_A$. In Spherepop they denote distinct objects because the histories of commitments they produce differ. For systems in which the number, order, or content of intermediate commitments carries physical, informational, or legal significance, the trace semantics loses information that the system cannot afford to discard.
\end{remark}

This is not a defect of traced monoidal categories; it is a consequence of the problem they are designed to solve. The relevant question is whether the problem of interest is one in which histories matter. Spherepop asserts that for a wide and important class of systems---those governed by irreversibility---they do.

\section{State Representation: Option Space and History}
\label{sec:state}

The primitive data structure of Spherepop is a pair representing the current state of an unfolding process.

\begin{definition}[Spherepop state]
\label{def:state}
Let $\Omega$ be a finite set called the \emph{option space}. A \emph{Spherepop state} is a pair
\[
(\Omega_t,\, H_t)
\]
where $\Omega_t \subseteq \Omega$ is the \emph{residual option space} at time $t$---the set of possibilities that have not yet been excluded or committed---and $H_t = [x_1, x_2, \ldots, x_k]$ is the \emph{commitment history}, an ordered list of elements that have been selected and recorded.
\end{definition}

The initial state of any computation is $(\Omega, \varnothing)$: the full option space is available and no commitments have yet been made. As the computation proceeds, $\Omega_t$ shrinks monotonically (possibilities are excluded but never reintroduced) and $H_t$ grows monotonically (commitments are appended but never retracted). These two monotonicity conditions are not incidental features of the notation but constitute the central structural constraint of the framework.

The asymmetry between $\Omega_t$ and $H_t$ is deliberate and significant. The residual option space $\Omega_t$ carries no ordering: it is a set, recording which possibilities remain without recording when or in what sequence alternatives were ruled out. The history $H_t$, by contrast, is an ordered list: it records not merely which commitments were made but the sequence in which they occurred. This asymmetry reflects the asymmetry of time. The future is a space of undifferentiated possibilities; the past is an ordered causal chain.

\begin{example}
Let $\Omega = \{a, b, c\}$. The initial state is $(\{a,b,c\},\, \varnothing)$. After the commitment $a$, the state becomes $(\{b,c\},\, [a])$. After a subsequent contextual restriction that eliminates $c$ without committing to it, the state becomes $(\{b\},\, [a])$. After the final commitment $b$, the state becomes $(\varnothing,\, [a,b])$.

Two alternative computations over the same option space might produce the states $(\varnothing,\, [a,b])$ and $(\varnothing,\, [b,a])$. Both have exhausted the option space, and if the observable outcome is merely the fact of exhaustion, the two computations appear equivalent. In Spherepop they are not: the histories $[a,b]$ and $[b,a]$ are distinct ordered lists, and the identity of each process is its history.
\end{example}

The state representation of Definition~\ref{def:state} is minimal in the following sense: it records exactly the information needed to reconstruct the observable state of the system via the \textsc{Collapse} operator defined in Section~\ref{sec:operators}, and no more. The discarded alternatives in $\Omega \setminus \Omega_t$ are genuinely lost to the history; they do not appear in $H_t$ because they were excluded rather than committed.

\section{The Three Primitive Operators}
\label{sec:operators}

Three operators act on Spherepop states. Together they constitute the complete operational vocabulary of the framework.

\subsection{Pop: Irreversible Commitment}

\textsc{Pop} is the fundamental operator of Spherepop. It performs an irreversible selection from the current residual option space and records that selection in the history.

\begin{definition}[\textsc{Pop}]
Let $(\Omega_t, H_t)$ be a Spherepop state and let $x \in \Omega_t$. The operator $\mathrm{Pop}_x$ acts as
\[
\mathrm{Pop}_x(\Omega_t,\, H_t) \;=\; \bigl(\Omega_t \setminus \{x\},\;\; H_t \cdot x\bigr),
\]
where $H_t \cdot x$ denotes the list obtained by appending $x$ to $H_t$.
\end{definition}

The key properties of \textsc{Pop} are the following. First, $x$ is removed from $\Omega_t$: once an element is committed, it is no longer available as a future possibility. Second, $x$ is appended to $H_t$: the commitment is recorded in causal order. Third, the operation is irreversible: there is no operator $\mathrm{Pop}^{-1}$ that restores $x$ to the option space and removes it from the history. The option space strictly shrinks with each application.

This irreversibility is the mathematical expression of a fact about the systems Spherepop is designed to model. In any process governed by genuine commitment---the signing of a contract, the emission of a photon, the writing of a git commit, the irreversible bifurcation of a developmental pathway---the committed state cannot be undone. The alternatives that were not chosen at the moment of commitment do not persist as latent possibilities; they are foreclosed.

\begin{remark}
The strict decrease in $|\Omega_t|$ after each \textsc{Pop} implies that a computation over a finite option space $\Omega$ terminates after at most $|\Omega|$ applications of \textsc{Pop}. The computation is therefore guaranteed to be finite provided the option space is finite and no \textsc{Bind} operation introduces new elements. Spherepop is not designed for infinite option spaces without modification; the finite case already exhibits all the structural features of interest.
\end{remark}

\subsection{Bind: Contextual Restriction}

\textsc{Bind} performs a contextual restriction of the option space without making a commitment. It applies an admissibility condition that narrows the set of future possibilities without recording any element in the history.

\begin{definition}[\textsc{Bind}]
Let $f : 2^\Omega \to 2^\Omega$ be a function satisfying $f(\Omega_t) \subseteq \Omega_t$ for all $\Omega_t$ (that is, $f$ is an interior operator on the powerset lattice). The operator $\mathrm{Bind}_f$ acts as
\[
\mathrm{Bind}_f(\Omega_t,\, H_t) \;=\; \bigl(f(\Omega_t),\;\; H_t\bigr).
\]
\end{definition}

The history $H_t$ is unchanged by \textsc{Bind}: because no commitment has been made, there is nothing to record. The option space $\Omega_t$ is replaced by $f(\Omega_t)$, which is smaller or equal. The elements in $\Omega_t \setminus f(\Omega_t)$ are silently excluded---they are not committed and therefore do not appear in $H_t$, but they are no longer available for future \textsc{Pop} operations.

This silent exclusion is a philosophically significant feature. \textsc{Bind} models the operation of a contextual constraint: a precondition, an admissibility filter, a physical law that rules out certain trajectories before any selection occurs. The excluded elements leave no trace in the causal history because they were never genuinely in play at the moment of commitment; they were ruled out by the structure of the problem rather than by a choice made within it.

\begin{example}
\label{ex:bind}
In the option space $\Omega = \{a, b, c\}$, the function $f(\Omega_t) = \Omega_t \setminus \{c\}$ represents the constraint ``$c$ is inadmissible.'' Applying $\mathrm{Bind}_f$ to the initial state:
\[
\mathrm{Bind}_f\bigl(\{a,b,c\},\, \varnothing\bigr) \;=\; \bigl(\{a,b\},\, \varnothing\bigr).
\]
The element $c$ has been excluded, but the history remains empty. The subsequent computation proceeds as if $c$ never existed as a genuine option.
\end{example}

The distinction between exclusion by \textsc{Bind} and exclusion by \textsc{Pop} corresponds to the distinction between structural impossibility and chosen commitment. An element excluded by \textsc{Bind} was never a real candidate; an element excluded by \textsc{Pop} was a genuine alternative that the process passed over. This distinction may or may not be recoverable from an external observation of the final state, but it is always present in the Spherepop state pair.

\subsection{Collapse: Reconstruction from History}

\textsc{Collapse} is the inverse operation in a loose sense: it reconstructs an observable state from the accumulated commitment history. It is not an inverse of \textsc{Pop} in the categorical sense---it does not restore the option space---but rather a functor from histories to observable states.

\begin{definition}[\textsc{Collapse}]
Let $s_0$ be a fixed root state and let $\{T_x\}_{x \in \Omega}$ be a family of state transformations, one for each element of the option space. For a history $H_t = [x_1, x_2, \ldots, x_n]$, the operator $\mathrm{Collapse}$ acts as
\[
\mathrm{Collapse}(H_t) \;=\; T_{x_n} \circ T_{x_{n-1}} \circ \cdots \circ T_{x_1}(s_0).
\]
\end{definition}

The observable state is not primitive. It is derived from the sequence of commitments by composing the associated transformations from left to right in historical order. The earliest commitment $x_1$ acts first on the root state $s_0$, and the most recent commitment $x_n$ acts last. The result is the state that the system would be in if it had actually executed those commitments in that sequence.

This derivation structure is the deepest claim of the Spherepop ontology. States are not given; they are constructed. What is given is the root state $s_0$---which may be thought of as the vacuum or the origin---and the ordered list of commitments. All other states are derived objects, computable from the history by \textsc{Collapse}.

\begin{remark}
The composition order in \textsc{Collapse} is that of diagrammatic composition in a category: $T_{x_1}$ is applied first, $T_{x_n}$ last. This matches the temporal order of commitments. Note that in general $T_{x_i} \circ T_{x_j} \neq T_{x_j} \circ T_{x_i}$: the history $[a, b]$ and the history $[b, a]$ may yield different observable states via \textsc{Collapse}, even though they contain the same set of elements. Commutativity of the transformations is an additional assumption that must be imposed if and when it holds; it is not part of the definition.
\end{remark}

\section{The Minimal Example: Three Operators over $\{a, b, c\}$}
\label{sec:example}

Having defined the three operators, it is instructive to trace through the minimal nontrivial Spherepop computation in full detail. Let $\Omega = \{a, b, c\}$, let the initial state be $(\{a,b,c\},\, \varnothing)$, and let $s_0$ be the root state.

\paragraph{Step 0.} The computation begins:
\[
(\{a,b,c\},\, \varnothing).
\]
All three possibilities are available and no commitments have been made.

\paragraph{Step 1: Apply $\mathrm{Bind}_f$ with $f(\Omega_t) = \Omega_t \setminus \{c\}$.}

The constraint ``$c$ is inadmissible'' narrows the option space:
\[
\bigl(\{a,b\},\, \varnothing\bigr).
\]
The history remains empty because no commitment has occurred. The element $c$ has been silently excluded by context.

\paragraph{Step 2: Apply $\mathrm{Pop}_a$.}

The system commits to $a$:
\[
\bigl(\{b\},\, [a]\bigr).
\]
The option space now contains only $b$. The history records that $a$ was the first commitment. The identity of the process, at this moment, is the ordered sequence $[a]$.

\paragraph{Step 3: Apply $\mathrm{Collapse}([a])$.}

The observable state is reconstructed:
\[
s \;=\; T_a(s_0).
\]
Even though the residual option space still contains $b$, the observable state of the system is $T_a(s_0)$---the root state transformed by the single committed element $a$.

This minimal computation already exposes the central structural difference between Spherepop and conventional evaluation. A traditional functional model would compute the value $T_a(s_0)$ and return it, discarding the alternative $b$ and the contextual exclusion of $c$ as implementation details. In Spherepop the pair $(\{b\},\, [a])$ is the genuine object of study. The residual alternative $b$ remains present in the state, recording that the computation was made in a context where $b$ was a genuine possibility that was passed over. The exclusion of $c$ is likewise recorded---albeit silently, in the gap between $\Omega$ and $\Omega_t$---as a constraint of the environment rather than a choice of the process.

\paragraph{Observation on identity.}

Two Spherepop computations over $\Omega = \{a, b, c\}$ that produce the same observable state $s = T_a(s_0)$ may differ in their causal histories. A computation that applies $\mathrm{Bind}_f$ before $\mathrm{Pop}_a$ produces the state $(\{b\},\, [a])$. A computation that applies only $\mathrm{Pop}_a$ with no prior \textsc{Bind} produces the state $(\{b, c\},\, [a])$. Both yield the same observable state via \textsc{Collapse}. In a purely extensional semantics they are the same. In Spherepop they are distinct: the first computation occurred in a context where $c$ had already been ruled out; the second occurred in a context where $c$ remained a live possibility. The causal provenance of the commitment differs, and that difference is preserved in the state representation.

\section{The History Algebra and the Free History Category}
\label{sec:algebra}

The three operators of Section~\ref{sec:operators}, together with the state representation of Section~\ref{sec:state}, constitute what we call the \emph{history algebra} of Spherepop. We now characterize its mathematical structure more precisely.

\begin{definition}[History algebra]
\label{def:histalg}
A \emph{history algebra} over a finite option space $\Omega$ consists of:
\begin{enumerate}
\item[(i)] the set of all Spherepop states $\{(\Omega_t, H_t) \mid \Omega_t \subseteq \Omega,\; H_t \in \Omega^*\}$, where $\Omega^*$ denotes the set of finite ordered lists over $\Omega$;
\item[(ii)] for each $x \in \Omega$, the operator $\mathrm{Pop}_x$ acting on states with $x \in \Omega_t$;
\item[(iii)] for each admissibility function $f$, the operator $\mathrm{Bind}_f$;
\item[(iv)] a root state $s_0$ and a family $\{T_x\}_{x\in\Omega}$ of transformations defining the operator $\mathrm{Collapse}$.
\end{enumerate}
\end{definition}

The algebraic laws governing these operators are sparse but decisive. \textsc{Pop} operations compose strictly by concatenation: $\mathrm{Pop}_{x_2} \circ \mathrm{Pop}_{x_1}$ produces history $[x_1, x_2]$, not $[x_2, x_1]$. The composition is therefore non-commutative in general. \textsc{Bind} operations compose by function composition: $\mathrm{Bind}_{f_2} \circ \mathrm{Bind}_{f_1}$ applies $f_1$ first and $f_2$ second. \textsc{Pop} and \textsc{Bind} interact as follows: $\mathrm{Pop}_x \circ \mathrm{Bind}_f$ is defined only when $x \in f(\Omega_t)$, that is, only when the admissibility filter has not excluded $x$ before the commitment.

The composition structure of histories is that of a free monoid $\Omega^*$ under concatenation, with the empty history $\varnothing$ as the identity element. This is the universal algebraic object generated by $|\Omega|$ generators with no relations---the freest possible monoid, with no equations identifying distinct words. That there are no relations is not a deficiency; it is the point. The history algebra imposes no equivalences on distinct commitment sequences, just as the free monoid imposes no equations on distinct words. Two different histories are always different objects.

This observation motivates the categorical characterization of Spherepop.

\begin{definition}[Free history category]
\label{def:freehist}
The \emph{free history category} $\mathcal{H}(\Omega)$ over a finite option space $\Omega$ is the category whose:
\begin{enumerate}
\item[(i)] objects are pairs $(\Omega_t, H)$ where $\Omega_t \subseteq \Omega$ and $H \in \Omega^*$;
\item[(ii)] morphisms from $(\Omega_t, H)$ to $(\Omega_t', H')$ are pairs $(\sigma, \tau)$ where $\sigma : \Omega_t \to \Omega_t'$ is a set map and $\tau \in \Omega^*$ satisfies $H' = H \cdot \tau$---that is, $H'$ extends $H$ by the commitment sequence $\tau$;
\item[(iii)] composition is given by $(\sigma', \tau') \circ (\sigma, \tau) = (\sigma' \circ \sigma,\, \tau \cdot \tau')$;
\item[(iv)] identity morphisms are $(\mathrm{id}_{\Omega_t}, \varnothing)$---the identity commits nothing and leaves the option space unchanged.
\end{enumerate}
\end{definition}

\begin{proposition}
The category $\mathcal{H}(\Omega)$ is a well-defined category. The \textsc{Pop} and \textsc{Bind} operators of Section~\ref{sec:operators} correspond to generating morphisms in $\mathcal{H}(\Omega)$, and \textsc{Collapse} is a functor $\mathrm{Collapse} : \mathcal{H}(\Omega) \to \mathcal{S}$ where $\mathcal{S}$ is the category of observable states and transformations.
\end{proposition}

\begin{proof}
Associativity of composition follows from associativity of concatenation in $\Omega^*$ and associativity of function composition. Identity morphisms satisfy $(\sigma', \tau') \circ (\mathrm{id}, \varnothing) = (\sigma', \tau')$ and $(\mathrm{id}, \varnothing) \circ (\sigma, \tau) = (\sigma, \tau)$, as required. The functor $\mathrm{Collapse}$ sends a history $H = [x_1, \ldots, x_n]$ to the composite transformation $T_{x_n} \circ \cdots \circ T_{x_1}$; functoriality follows from the fact that concatenation of histories corresponds to composition of transformations.
\end{proof}

The contrast with traced monoidal categories can now be stated precisely. In a traced monoidal category $\mathcal{C}$, two morphisms $f, g : A \otimes U \to B \otimes U$ that produce the same trace $\mathrm{Tr}^U_{A,B}(f) = \mathrm{Tr}^U_{A,B}(g) : A \to B$ are identified for the purposes of the external interface. The trace is a quotient: it identifies morphisms whose internal behavior differs but whose external effect is the same. In $\mathcal{H}(\Omega)$ there is no such quotient. Two morphisms with the same source, target, and observable output but different commitment sequences $\tau \neq \tau'$ are distinct morphisms. The category $\mathcal{H}(\Omega)$ is not a quotient of anything; it is a free object. Its morphisms are literally the words in the free monoid $\Omega^*$, with no equivalences imposed.

\begin{remark}[Path objects and causal categories]
The morphisms of $\mathcal{H}(\Omega)$ are path objects in the sense of abstract homotopy theory: they are not equivalence classes of paths but the paths themselves, with path identity being literal equality of ordered sequences. This is also the sense in which a Spherepop computation is a path object: its identity is not the homotopy class of its trajectory through configuration space but the specific ordered sequence of events that constituted it. The categorical semantics of Spherepop is therefore not that of a quotient category but that of a path groupoid---or rather, since the paths are irreversible, a path category with no inverses.
\end{remark}

\section{Apparent Cycles from Dense Irreversible Chains}
\label{sec:emergence}

One of the most counterintuitive features of the Spherepop model is the way cyclic behavior emerges from what is, at the level of internal structure, a strictly non-cyclic process. The option space shrinks monotonically and the history grows monotonically; there is no literal loop. Yet external observers of a Spherepop computation frequently perceive periodicity, recurrence, or feedback. This section explains the mechanism.

Consider a computation that proceeds as a long alternating sequence of \textsc{Bind} and \textsc{Pop} operations:
\[
\mathrm{Bind}_{f_1} \to \mathrm{Pop}_{x_1} \to \mathrm{Bind}_{f_2} \to \mathrm{Pop}_{x_2} \to \cdots \to \mathrm{Bind}_{f_n} \to \mathrm{Pop}_{x_n}.
\]
The resulting history is $H = [x_1, x_2, \ldots, x_n]$. Suppose further that the admissibility functions $\{f_k\}$ are \emph{renewing}: at each stage $k$, the function $f_k$ restricts the current option space to a subset that resembles the option space available at some earlier stage $k' < k$. For instance, if $\Omega = \{a, b, c\}$ and the computation alternately commits to $a$ and then reintroduces a fresh copy of $\{a, b, c\}$ through a \textsc{Bind} operation that acts on an extended option space, the external observer---who sees only the sequence of committed elements---may observe the pattern $[a, a, a, \ldots]$ and infer a cycle.

The inference is correct at the macroscopic level and incorrect at the structural level. At the macroscopic level, the external output of the computation does exhibit periodicity. At the structural level, the history $[a, a, a, \ldots]$ is a strictly growing list. Each occurrence of $a$ is a distinct commitment at a distinct moment in the causal chain. The apparent cycle is the macroscopic shadow of a rapidly extending causal thread.

\begin{proposition}[Apparent cycles from dense irreversible chains]
Let $\Omega$ be a finite option space and let $\{\Omega^{(k)}\}$ be a sequence of option spaces with $\Omega^{(k+1)} \supseteq \Omega^{(k)}$ for all $k$ (i.e., the effective option space is periodically refreshed by context). Let a Spherepop computation commit to elements $x_1, x_2, x_3, \ldots$ from successive refreshed spaces. If the commitment rule is periodic in the sense that $x_{k+p} = x_k$ for some period $p$ and for all $k \geq k_0$, then the observable output sequence via \textsc{Collapse} is periodic with period $p$, while the history $H = [x_1, x_2, \ldots]$ is strictly non-repeating as a list.
\end{proposition}

\begin{proof}
Periodicity of the output sequence follows by definition: $\mathrm{Collapse}([x_1, \ldots, x_n]) = T_{x_n} \circ \cdots \circ T_{x_1}(s_0)$, and if the committed elements repeat with period $p$, the composition of transformations repeats with the same period in its suffix. Non-repetition of the history follows from the fact that the history is an append-only list and $H_{t+1}$ strictly contains $H_t$ as a proper prefix.
\end{proof}

The practical implication is that Spherepop can model cyclic phenomena---heartbeats, oscillating chemical reactions, periodic regulatory feedback, circadian rhythms---without introducing any cyclic structure into its underlying representation. The cycles are macroscopic invariants of a monotonically growing history. This is not merely a formal curiosity; it is precisely the structure of real physical and biological systems in which apparent cycles are the observable consequence of an underlying time-directed causal process that never genuinely repeats.

The contrast with traced monoidal categories is again instructive. In the traced setting, a cyclic computation is modeled by an actual loop: the morphism $f : A \otimes U \to B \otimes U$ has a genuinely cyclic feedback wire $U$, and the trace collapses the loop into a fixed-point. The cycle is in the morphism. In Spherepop, the cycle is nowhere in the morphism; it is only in the external observation of the output sequence. The internal structure is always acyclic.

\section{Connections to Append-Only Systems}
\label{sec:connections}

The mathematical structure identified in the preceding sections---an append-only history, a shrinking option space, and an observable state derived by composing committed transformations---appears in several domains of computer science and distributed systems under different names. Recognizing these connections is not merely an observation of analogy; it suggests that Spherepop is the natural abstract algebraic characterization of a pattern that arises wherever irreversibility and ordered provenance are structurally required.

\paragraph{Event sourcing.} In the event sourcing architectural pattern, the state of a system is not stored directly but derived from an append-only log of events. Each event is immutable once recorded; the current state is reconstructed at any moment by replaying the event log from the beginning. This is precisely the structure of Spherepop's \textsc{Collapse} operator: the observable state is $T_{x_n} \circ \cdots \circ T_{x_1}(s_0)$, where each $x_i$ corresponds to an event and $s_0$ is the initial state of the aggregate. The event log is the history $H_t$, and the domain aggregate is the result of \textsc{Collapse}. The Spherepop framework can therefore be understood as the categorical semantics of event-sourced systems, making precise the algebraic laws that such systems implicitly obey.

\paragraph{Version control and git.} A git repository is an append-only directed acyclic graph of commits. Each commit records a transformation of the repository state relative to its parents, and the current state of any branch is derived by traversing the commit graph from the root. The history $H_t = [x_1, \ldots, x_n]$ in Spherepop corresponds to the sequence of commits on a linear branch; \textsc{Pop} corresponds to the act of committing; \textsc{Bind} corresponds to the application of a merge filter or a pre-commit hook that restricts the admissible changes; and \textsc{Collapse} corresponds to checking out---reconstructing the working tree state from the commit history. The non-commutativity of Spherepop histories corresponds to the well-known non-commutativity of git merges: rebasing a branch as $[a, b]$ produces a different repository state than rebasing it as $[b, a]$ whenever the transformations $T_a$ and $T_b$ modify overlapping files.

\paragraph{Ledgers and blockchains.} A financial ledger is an append-only sequence of transactions. The current balance of any account is derived from the ledger by composing the signed transformations corresponding to each transaction---credits and debits applied in temporal order. A blockchain generalizes this by making the append-only property cryptographically enforced: each block references the hash of its predecessor, making retrospective alteration of the history computationally infeasible. The Spherepop framework provides a clean algebraic characterization of the invariants that both systems rely upon: the free history category $\mathcal{H}(\Omega)$ is the abstract algebra of a system whose identity is its ordered record of commitments.

\paragraph{Causal histories in physics.} In the causal set approach to quantum gravity, spacetime is modeled as a locally finite partial order of events, where the partial order encodes the causal precedence relation. The history of a physical system is the causal set of events that led to its current state, and the state is derived by composing the effects of those events in causal order. This is formally identical to the \textsc{Collapse} operator applied to a history $H_t$ where the ordering is causal rather than merely temporal. The Spherepop framework may therefore be understood as a discretized version of causal set dynamics, with the option space $\Omega$ playing the role of the future light cone of admissible next events and each \textsc{Pop} operation corresponding to the actualization of one event from that cone.

\section{Conclusion}

The foregoing analysis has developed the formal structure of Spherepop as a minimal append-only history algebra equipped with three operations: \textsc{Pop}, which performs irreversible commitment; \textsc{Bind}, which applies contextual restriction without commitment; and \textsc{Collapse}, which derives the observable state from the ordered commitment history. The natural categorical home of this algebra is the free history category $\mathcal{H}(\Omega)$, whose morphisms are ordered sequences of commitments in the free monoid $\Omega^*$ and whose composition law is list concatenation.

The structural contrast with traced monoidal categories is precise and illuminating. The trace operator achieves its power by identifying morphisms with the same external behavior, regardless of internal path---it is a quotient construction that abstracts over the details of feedback loops. The free history category $\mathcal{H}(\Omega)$ is the opposite extreme: it is the freest category consistent with the monotonicity constraints of the Spherepop state, and it identifies no two distinct histories. The identity of a Spherepop process is its history, not its output. The trace collapses the path into a morphism; Spherepop refuses that collapse and keeps the path.

This refusal is not a deficiency. It is the correct formal response to a genuine structural requirement: the requirement that the provenance, order, and identity of intermediate commitments be preserved as first-class mathematical structure. The systems that satisfy this requirement---event-sourced architectures, version-controlled repositories, cryptographic ledgers, causal set models of spacetime---are not exotic edge cases. They are among the most consequential computational and physical systems that exist. Spherepop provides them with the categorical semantics they deserve.

\end{document}