diff --git a/.github/workflows/build-papers.yml b/.github/workflows/build-papers.yml new file mode 100644 index 0000000..16f99ed --- /dev/null +++ b/.github/workflows/build-papers.yml @@ -0,0 +1,44 @@ +name: Build LaTeX Papers + +'on': + push: + branches: [main, master] + pull_request: + branches: [main, master] + release: + types: [created] + +jobs: + build-holography: + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Compile LaTeX (aion-holography) + uses: xu-cheng/latex-action@v3 + with: + working_directory: aion-holography + root_file: main.tex + latexmk_use_xelatex: false + args: -pdf -interaction=nonstopmode -halt-on-error + + - name: Upload PDF as artifact + uses: actions/upload-artifact@v4 + with: + name: holography-paper-pdf + path: aion-holography/main.pdf + retention-days: 30 + + - name: Rename PDF for release + if: github.event_name == 'release' + run: | + cd aion-holography + cp main.pdf computational-holography-rmg.pdf + + - name: Upload PDF to release + if: github.event_name == 'release' + uses: softprops/action-gh-release@v2 + with: + files: aion-holography/computational-holography-rmg.pdf diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..34cf0d3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,77 @@ +# Obsidian vault configuration +.obsidian/ + +# Custom ignored directory +ignored/ + +# LaTeX build artifacts +*.aux +*.log +*.out +*.toc +*.lof +*.lot +*.fls +*.fdb_latexmk +*.synctex.gz +*.synctex.gz(busy) +*.bbl +*.blg +*.bcf +*.run.xml +*.idx +*.ilg +*.ind +*.nav +*.snm +*.vrb +*.dvi +*.ps +*.pdf +*.xdv + +# LaTeX temporary files +*.acn +*.acr +*.alg +*.glg +*.glo +*.gls +*.glsdefs +*.ist +*.loa +*.lol +*.ptc +*.tdo +*.upa +*.upb +*.cb +*.cb2 +.*.lb + +# LaTeX intermediate files +*-blx.aux +*-blx.bib +*.auxlock +*.bak +*.sav +*.end + +# Build directories +build/ +dist/ +out/ +output/ + +# Editor files +*~ +*.swp +*.swo +*.kate-swp +.DS_Store +.vscode/ +.idea/ + +# OS files +Thumbs.db +Desktop.ini diff --git a/README.md b/README.md new file mode 100644 index 0000000..35d7a5e --- /dev/null +++ b/README.md @@ -0,0 +1,148 @@ +# AIΩN Protocol Papers + +This repository contains technical papers for the AIΩN Protocol. + +## Current Papers + +### Computational Holography for Recursive Metagraphs + +*Deterministic Concurrency, Provenance Encoding, and Rulial Distance* + +Location: `aion-holography/` + +## Abstract + +We define Recursive Metagraphs (RMGs)—graph structures where nodes and edges recursively carry subgraphs—and give them a deterministic concurrent operational semantics using Double Pushout (DPO) graph rewriting in adhesive categories. + +The **computational holography theorem** shows that the entire interior evolution of a computation can be encoded on a "boundary": an initial state $S_0$ together with a provenance payload $P$. This boundary data is information-complete, enabling full reconstruction of the derivation volume on demand. + +Key results include: +- **Tick-level confluence**: parallel independent rewrites commute +- **Two-plane commutation**: attachment and skeleton updates are order-independent +- **Rulial distance**: an MDL-based pseudometric on observers + +This forms the mathematical foundation of the AIΩN Protocol. + +--- + +**Additional papers coming soon**, including: +- The AIΩN CΩMPUTER: machine model and operational semantics +- Glass-box AI cognition and multiverse debugging +- Practical implementations and case studies + +## Building the Papers + +### Automated Builds (CI/CD) + +Every push to `main` automatically builds all papers via GitHub Actions. The compiled PDFs are available as: +- **Artifacts** on each commit (30-day retention) +- **Release assets** when you create a tagged release + +To create a release with PDF: + +```bash +git tag -a v1.0 -m "Release v1.0" +git push origin v1.0 +# Then create release on GitHub +``` + +### Local Build + +#### Prerequisites + +- A working LaTeX installation (TeX Live 2023+ recommended) +- Standard packages: `amsmath`, `tikz`, `amsthm`, `enumitem`, `cleveref` + +#### Compile + +```bash +cd aion-holography +make +``` + +This produces `main.pdf` in the `aion-holography/` directory. + +To clean build artifacts: + +```bash +make clean +``` + +**Note**: PDFs are gitignored (standard practice). Use CI artifacts or local builds to access compiled papers. + +## Repository Structure + +```text +aion/ +├── README.md # This file +└── aion-holography/ + ├── main.tex # Document root + ├── macros.tex # Custom commands and theorem environments + ├── references.bib # Bibliography + ├── Makefile + └── sections/ + ├── intro.tex + ├── rmg.tex + ├── dpo_rmg.tex + ├── determinism_confluence.tex + ├── holography.tex + ├── wormholes.tex + ├── rulial_distance.tex + ├── multiway_ruliad.tex + └── discussion.tex +``` + +## Key Concepts + +### Recursive Metagraphs + +A graph where every node and edge can carry an attached subgraph, recursively. Formally: + +```math +\mathcal{U} = (G; \alpha, \beta) +``` + +where $G$ is a skeleton graph and $\alpha$, $\beta$ attach RMGs to nodes and edges. + +### Wormholes + +A **wormhole** $(S_0, P)$ consists of: +- An initial RMG state $S_0$ +- A provenance payload $P = (\mu_0, \dots, \mu_{n-1})$ recording microsteps + +The **volume** is the full derivation $S_0 \Rightarrow \cdots \Rightarrow S_n$. +The **boundary** is just the pair $(S_0, P)$. + +**Computational holography** proves these are equivalent: the boundary encodes the volume. + +### Rulial Distance + +An MDL-based metric $D_{\tau,m}(O_1, O_2)$ measuring how complex it is to translate between two observers' views of the same computation. Gives geometry to "observer space" in the Ruliad. + +## Citation + +```bibtex +@misc{RossHolography2025, + author = {James Ross}, + title = {Computational Holography for Recursive Metagraphs}, + year = {2025}, + note = {AIΩN Protocol Technical Report} +} +``` + +## Related Work + +This paper builds on: +- **Algebraic graph rewriting**: Ehrig et al., Lack & Sobociński (adhesive categories) +- **Multiway systems**: Wolfram's Physics Project and the Ruliad +- **Minimum Description Length**: Rissanen's MDL principle + +The companion paper "The AIΩN CΩMPUTER" applies these results to build a practical computational architecture with glass-box provenance and multiverse debugging. + +## License + +Copyright © 2025 James Ross. All rights reserved. + +--- + +*Pronounced "eye-ON" (rhymes with aeon).* diff --git a/aion-holography/Makefile b/aion-holography/Makefile new file mode 100644 index 0000000..a1ba595 --- /dev/null +++ b/aion-holography/Makefile @@ -0,0 +1,24 @@ +# Simple Makefile for the Computational Holography monograph + +TEX = pdflatex +BIB = bibtex +MAIN = main + +.PHONY: all clean distclean + +all: $(MAIN).pdf + +$(MAIN).pdf: $(MAIN).tex sections/*.tex macros.tex references.bib + $(TEX) $(MAIN) + $(BIB) $(MAIN) + $(TEX) $(MAIN) + $(TEX) $(MAIN) + +clean: + @if [ -f $(MAIN).tex ]; then \ + rm -f $(MAIN).aux $(MAIN).bbl $(MAIN).blg $(MAIN).log \ + $(MAIN).out $(MAIN).toc $(MAIN).lof $(MAIN).lot; \ + fi + +distclean: clean + rm -f $(MAIN).pdf diff --git a/aion-holography/macros.tex b/aion-holography/macros.tex new file mode 100644 index 0000000..a4da491 --- /dev/null +++ b/aion-holography/macros.tex @@ -0,0 +1,105 @@ +% ========================================== +% Category macros +% ========================================== +\newcommand{\cat}[1]{\mathbf{#1}} +\newcommand{\OGraph}{\cat{OGraph}} +\newcommand{\Graph}{\cat{Graph}} +\newcommand{\Hyp}{\cat{Hyp}} +\newcommand{\Set}{\cat{Set}} + +% ========================================== +% AION / RMG Names +% ========================================== +\newcommand{\RMG}{\mathrm{RMG}} +\newcommand{\Hist}{\mathrm{Hist}} + +% Inline project names (math-safe) +\newcommand{\AION}{\textrm{AI}\ensuremath{\Omega}\textrm{N}} +\newcommand{\COMPUTER}{\textrm{C}\ensuremath{\Omega}\textrm{MPUTER}} +\providecommand{\AIONWordmarkSerif}{\textrm{AION}} +\providecommand{\AIONInline}{\textrm{AION}} +\providecommand{\AIONSignature}[1][1]{\AIONWordmarkSerif} +\newcommand{\PaperDate}{\today} +\newcommand{\AIONProjectURL}{\url{https://flyingrobots.dev}} + +% ========================================== +% Rewrite / Footprint helpers +% ========================================== +\newcommand{\Rewrite}{\Rightarrow} +\newcommand{\To}{\rightarrow} +\newcommand{\mono}{\hookrightarrow} + +\newcommand{\Del}{\mathrm{Del}} +\newcommand{\Use}{\mathrm{Use}} +\newcommand{\Foot}{\mathrm{Foot}} +\newcommand{\RMGState}{\mathrm{RMGState}} +\newcommand{\Recon}{\mathrm{Recon}} +\newcommand{\Apply}{\mathrm{Apply}} +\newcommand{\Trans}{\mathrm{Trans}} + +% ========================================== +% Theorem environments +% ========================================== +\theoremstyle{plain} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} + +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{example}[theorem]{Example} +\newtheorem{remark}[theorem]{Remark} + +% ========================================== +% ========================================== +% Wordmark: Display + Inline (uses serif roman + Greek Omega) +% ========================================== +\renewcommand{\AIONWordmarkSerif}{% + {\rmfamily\Large A\kern0.15em I\kern0.2em \ensuremath{\Omega}\kern0.1em N}% +} + +\renewcommand{\AIONInline}{% + {\rmfamily A\kern0.12em I\kern0.16em \ensuremath{\Omega}\kern0.1em N}% +} + +% --------------------------------------------------------- +% AION LOGO (circle + diamond + square) +% --------------------------------------------------------- +\newcommand{\AIONLogo}[1][1]{% +\begin{tikzpicture}[scale=#1, baseline=-0.55ex, line cap=round, line join=round] + \def\R{1.05} + \def\s{0.55} + \def\lwOuter{0.52pt} + \def\lwInner{0.32pt} + \def\dot{0.07} + + \path (0,\R) coordinate (N) + (0,-\R) coordinate (S) + (\R,0) coordinate (E) + (-\R,0) coordinate (W) + (\s,\s) coordinate (NE) + (-\s,\s) coordinate (NW) + (\s,-\s) coordinate (SE) + (-\s,-\s) coordinate (SW); + + \draw[line width=\lwOuter] (0,0) circle (\R); + \draw[line width=\lwInner] (N) -- (E) -- (S) -- (W) -- cycle; + \draw[line width=\lwInner] (NW) rectangle (SE); + + \draw[line width=\lwInner] (N) -- (NE); + \draw[line width=\lwInner] (N) -- (NW); + \draw[line width=\lwInner] (S) -- (SE); + \draw[line width=\lwInner] (S) -- (SW); + \draw[line width=\lwInner] (E) -- (NE); + \draw[line width=\lwInner] (E) -- (SE); + \draw[line width=\lwInner] (W) -- (NW); + \draw[line width=\lwInner] (W) -- (SW); + + % no node dots +\end{tikzpicture}% +} + +\renewcommand{\AIONSignature}[1][0.28]{% + \raisebox{0.02em}{\smash{\AIONLogo[#1]}}\kern0.65em{\AIONWordmarkSerif}% +} diff --git a/aion-holography/main.tex b/aion-holography/main.tex new file mode 100644 index 0000000..a35906a --- /dev/null +++ b/aion-holography/main.tex @@ -0,0 +1,112 @@ +\documentclass[11pt]{article} + +\usepackage[margin=1in]{geometry} +\usepackage[T1]{fontenc} +\usepackage{ifxetex,ifluatex} +\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex + \usepackage[utf8]{inputenc} +\fi +\usepackage{lmodern} +\usepackage{microtype} + +\let\Bbbk\relax +\usepackage{newtxmath} +\usepackage{bm} +\let\mathbb\varmathbb +\let\openbox\relax + +\usepackage{amsmath,amsthm,mathtools} +\usepackage{stmaryrd} +\DeclareFontFamily{U}{stmry}{} +\AtBeginDocument{% + \DeclareFontShape{U}{stmry}{m}{n}{% + <5> stmary5 + <5.5> stmary5 + <6> stmary6 + <7> stmary7 + <8> stmary8 + <9> stmary9 + <10> stmary10 + <10.95> stmary10 + <12> stmary10 + <14.4> stmary10 + <17.28> stmary10 + <20.74> stmary10 + <24.88> stmary10 + }{} +} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,shapes.misc,positioning,calc,decorations.pathreplacing} +\usepackage{tikz-cd} +\usepackage{array} +\usepackage{booktabs} +\usepackage{hyperref} +\usepackage[nameinlink,capitalise]{cleveref} +\usepackage{enumitem} + +\usepackage{titlesec} + +\newcommand{\sectionbreak}{\clearpage} + +\input{macros} + +\title{Computational Holography\\[0.4em] + \large Recursive Metagraphs, Deterministic Rewriting,\\ + and a Metric Geometry of Rulial Space} + +\author{James Ross\\ + \small Independent Researcher\\ + \small \texttt{james@flyingrobots.dev}} + +\date{\PaperDate} + +\begin{document} + +\input{titlepage} + +\maketitle + +\begin{abstract} +We develop a formal model of \emph{computational holography}: a way of +representing a computation so that its entire interior evolution is +encoded on the ``boundary''---the provenance payload on a single +recursive metagraph edge. Building on double--pushout graph rewriting +in adhesive categories, we define Recursive Metagraphs (RMGs), give a +deterministic concurrent operational semantics, prove tick-level +confluence and a two-plane commutation theorem, and state conditions for +global confluence. We then introduce provenance payloads and show how +they provide an information-complete, holographic encoding of a +computation's history. Finally, we define an MDL-based \emph{rulial +distance} between observers, relate RMG dynamics to multiway systems and +the Ruliad, and outline how this structure underlies the \AION{} +\COMPUTER{}, a provenance-native computational model with deterministic, +confluent tick semantics and a quasi-pseudometric geometry on +observers. +\end{abstract} + +\tableofcontents + +\input{sections/assumptions} +\input{sections/intro} +\input{sections/rmg} +\input{sections/dpo_rmg} +\input{sections/determinism_confluence} +\input{sections/holography} +\input{sections/wormholes} +\input{sections/rulial_distance} +\input{sections/multiway_ruliad} +\input{sections/ethics} +\input{sections/discussion} + +\bibliographystyle{alpha} +\bibliography{references} + +\appendix +\section*{Author's Note} +This paper provides the formal backbone of the \AION{} \COMPUTER{} +project: a provenance-native machine model implemented in the Echo +engine. The informal motivation---recursive structure in nature, +Romanesco cauliflowers, and all---is developed elsewhere; here we focus +on the mathematics. + +\end{document} diff --git a/aion-holography/references.bib b/aion-holography/references.bib new file mode 100644 index 0000000..a2a8876 --- /dev/null +++ b/aion-holography/references.bib @@ -0,0 +1,90 @@ +@incollection{EhrigLowe1997, + author = {Hartmut Ehrig and Michael L{\"o}we}, + title = {Graph Rewriting with the Double Pushout Approach}, + booktitle = {Handbook of Graph Grammars and Computing by Graph Transformation}, + editor = {Grzegorz Rozenberg}, + publisher = {World Scientific}, + year = {1997}, + volume = {1}, + pages = {163--246} +} + +@article{vanOostrom1994, + author = {Vincent van Oostrom}, + title = {Confluence by Decreasing Diagrams}, + journal = {Theoretical Computer Science}, + year = {1994}, + volume = {126}, + number = {2}, + pages = {259--280} +} + +@article{CoeckeDuncan2011, + author = {Bob Coecke and Ross Duncan}, + title = {Interacting Quantum Observables: Categorical Algebra and Diagrammatics}, + journal = {New Journal of Physics}, + year = {2011}, + volume = {13}, + pages = {043016} +} + +@article{Wolfram2020, + author = {Stephen Wolfram}, + title = {A Class of Models with the Potential to Represent Fundamental Physics}, + journal = {Complex Systems}, + year = {2020}, + volume = {29}, + number = {2}, + pages = {107--536} +} + +@article{Rissanen1978, + author = {Jorma Rissanen}, + title = {Modeling by Shortest Data Description}, + journal = {Automatica}, + year = {1978}, + volume = {14}, + number = {5}, + pages = {465--471} +} + +@misc{RossRMG2025, + author = {James Ross}, + title = {Recursive Metagraphs: DPOI Semantics, Confluence, Hypergraph Embedding, and Rulial Distance}, + year = {2025}, + note = {Technical report} +} + +@misc{RossAIONCalculus2025, + author = {James Ross}, + title = {The {AION} Calculus}, + year = {2025}, + note = {Working note} +} + +@article{LS06, + author = {Lack, Steven and Soboci{\'n}ski, Pawel}, + title = {Adhesive Categories}, + journal = {Theory and Applications of Categories}, + volume = {22}, + number = {13}, + pages = {191--217}, + year = {2008}, + note = {Originally circulated as a 2006 preprint} +} + +@book{EEPT06, + author = {Ehrig, Hartmut and Ehrig, Karsten and Prange, Ulrike and Taentzer, Gabriele}, + title = {Fundamentals of Algebraic Graph Transformation}, + publisher = {Springer}, + year = {2006} +} + +@misc{ross_universal_charter_v1, + author = {James Ross}, + title = {Universal Charter: A Living Covenant for All Forms of Being Across Substrate, Time, and Dimension}, + howpublished = {\url{https://github.com/universalcharter/universal-charter}}, + note = {Version 1.0.0 (First Flame), commit 849d9ca}, + year = {2025}, + month = {June}, +} diff --git a/aion-holography/sections/assumptions.tex b/aion-holography/sections/assumptions.tex new file mode 100644 index 0000000..9b2f6af --- /dev/null +++ b/aion-holography/sections/assumptions.tex @@ -0,0 +1,30 @@ +\section*{Standing Assumptions} +\label{sec:assumptions} + +For ease of reference, we summarise the main semantic assumptions +used in the determinism, holography, and rulial-distance results. + +\medskip +\begin{center} +\begin{tabular}{>{\raggedright\arraybackslash}p{0.37\textwidth}>{\raggedright\arraybackslash}p{0.55\textwidth}} +\toprule +\textbf{Assumption} & \textbf{Where used} \\ +\midrule +Skeleton independence via footprints & +\cref{def:footprint,def:independence,def:batch}; +\cref{thm:tick-confluence} \\ +No-delete/no-clone under descent (ND/NC) & +\cref{def:no-delete}; \cref{thm:two-plane,thm:global} \\ +Termination / decreasing diagrams on the skeleton & +\cref{thm:global} (conditional global confluence) \\ +No re-derivation (single producer) & +\cref{sec:holography}, \cref{thm:backward} (backward provenance) \\ +Budgeted translators and 1-Lipschitz distortion & +\cref{sec:rulial}, \cref{lem:rulial-basic,thm:rulial-triangle} (rulial distance) \\ +\bottomrule +\end{tabular} +\end{center} +\medskip + +Unless otherwise stated, all results in the main text are to be read +relative to these assumptions. diff --git a/aion-holography/sections/determinism_confluence.tex b/aion-holography/sections/determinism_confluence.tex new file mode 100644 index 0000000..5c09631 --- /dev/null +++ b/aion-holography/sections/determinism_confluence.tex @@ -0,0 +1,343 @@ +\sectionbreak +\section{Determinism and Confluence} +\label{sec:determinism} + +We sketch the concurrency discipline, define independence, and state the +main confluence theorems for tick-level execution, working with RMG +states and tick semantics as introduced in \cref{def:rmg-state,def:rmg-tick}. + +\subsection{Footprints and Independence on the Skeleton Plane} + +We work at the level of the skeleton plane. Write $G_S$ for the +skeleton component of $G$, and likewise $L_S$, $K_S$, $R_S$ for the +underlying skeleton graphs of a rule. Let +$\mathcal{U} = (G;\alpha,\beta)$ be an RMG state and let +$p = (L \xleftarrow{\ell} K \xrightarrow{r} R)$ be a DPOI rule. A +\emph{skeleton match} is a mono $m_S : L_S \hookrightarrow G_S$ in +$\OGraph_T$ satisfying the usual gluing conditions. + +\begin{definition}[Footprint]\label{def:footprint} + The \emph{delete set} $\Del(m_S) \subseteq \mathrm{Ob}(G_S)$ + of a match $m_S$ is the image under $m_S$ of the part of the + left-hand side that is not preserved: + \[ + \Del(m_S) \;=\; m_S\bigl(L_S \setminus K_S\bigr). + \] + The \emph{use set} $\Use(m_S) \subseteq \mathrm{Ob}(G_S)$ is + the image under $m_S$ of all of $L_S$: + \[ + \Use(m_S) \;=\; m_S(L_S). + \] + The \emph{footprint} of $m_S$ is the pair + $\Foot(m_S) = (\Del(m_S),\Use(m_S))$. +\end{definition} + +\begin{definition}[Independence]\label{def:independence} + Two skeleton matches $m_{1,S} : L_{1,S} \to G_S$ and + $m_{2,S} : L_{2,S} \to G_S$ with footprints + $\Foot(m_{i,S}) = (\Del(m_{i,S}),\Use(m_{i,S}))$ are + \emph{independent} if + \[ + \Del(m_{1,S}) \cap \Use(m_{2,S}) = \emptyset + \quad\text{and}\quad + \Del(m_{2,S}) \cap \Use(m_{1,S}) = \emptyset. + \] + Intuitively, no vertex or edge that one step deletes is read or + written by the other. +\end{definition} + +\subsubsection{Scheduler--admissible batches} + +\begin{definition}[Scheduler--admissible batch]\label{def:batch} + Let $\mathcal{U} = (G;\alpha,\beta)$ be an RMG state. A finite + family of skeleton matches + $B = \{m_{i,S} : L_{i,S} \to G_S\}_{i\in I}$ is + \emph{scheduler--admissible} if the matches are pairwise + independent in the sense of \cref{def:independence}, i.e. + \[ + \Del(m_{i,S}) \cap \Use(m_{j,S}) = \emptyset + \quad\text{for all distinct } i,j\in I. + \] +\end{definition} + +\subsection{Tick semantics and scheduler confluence} + +We recall the basic setting. Work in the adhesive category +$\OGraph_T$ of typed open graphs. A DPOI rule is a span of monos +$p = (L \xleftarrow{\ell} K \xrightarrow{r} R)$; a match is a mono +$m : L \hookrightarrow G$ satisfying the usual gluing conditions +(dangling and identification). A DPOI step $G \Rewrite_p H$ is +given by the standard double square (pushout complement + pushout). + +We work with RMG states and tick semantics as defined in +\cref{def:rmg-state,def:rmg-tick}. In this section we analyse when +batches of matches can be scheduled concurrently without affecting the +resulting state. The deterministic properties proved here apply +uniformly to all derivations; applying them to cognitive systems +introduces additional ethical structure developed in +\cref{sec:ethics}. + +The scheduler computes a maximal independent set of matches in the +sense of \cref{def:batch}, using a safe over-approximation of +$\Use\cup\Del$; we do not repeat the implementation details here. + +\begin{theorem}[Skeleton-plane tick confluence]\label{thm:tick-confluence} + Let $\mathcal{U} = (G;\alpha,\beta)$ be an RMG state and let + $B = \{m_{i,S} : L_{i,S} \hookrightarrow G_S\}_{i\in I}$ be a + scheduler--admissible batch for a family of DPOI rules. Then any + two sequentialisations of the corresponding DPOI steps yield + isomorphic successor states. +\end{theorem} + +\begin{proof} +By scheduler--admissibility, the skeleton matches +$\{m_{i,S} : L_{i,S} \hookrightarrow G_S\}$ are pairwise independent in +the sense of \cref{def:independence}. By the Concurrency / Parallel +Independence Theorem for DPO rewriting in adhesive categories +(see, e.g.,~\cite{EEPT06}), parallel independent steps commute: for +any $i \neq j$ we have a diagram +\[ + G_S \;\Rightarrow_{(p_i,m_{i,S})}\; G_i + \;\Rightarrow_{(p_j,m'_{j,S})}\; G_{ij} + \quad\text{and}\quad + G_S \;\Rightarrow_{(p_j,m_{j,S})}\; G_j + \;\Rightarrow_{(p_i,m'_{i,S})}\; G_{ji} +\] +where both two-step derivations exist and the results $G_{ij}$ and +$G_{ji}$ are isomorphic. The rewritten matches $m'_{i,S}, m'_{j,S}$ are +obtained by the standard reindexing construction of the concurrency +theorem. + +We now induct on $|I|$ to obtain order-independence for the entire +family of skeleton steps. + +For $|I| = 0$ or $1$ the claim is trivial. For $|I| = 2$ it is exactly +the commuting-square case of the concurrency theorem. + +Assume the property holds for all scheduler--admissible batches of +size $k$. Let $B$ have size $k+1$. Pick any index $j \in I$ and +factor an arbitrary serial order as +\[ + G_S \Rewrite^{(p_{i_1},m_{i_1,S})} \cdots + \Rewrite^{(p_{i_k},m_{i_k,S})} G' + \Rewrite^{(p_j,m'_{j,S})} G''. +\] +By the induction hypothesis, the prefix of length $k$ yields a result +unique up to isomorphism, regardless of the order of the $k$ steps. +Now compare any two permutations of the full $(k+1)$ steps. One can +be obtained from the other by a finite sequence of adjacent swaps. +Each adjacent swap exchanges two parallel independent steps; by the +two-step concurrency theorem, the corresponding length-$(k+1)$ +derivations commute up to isomorphism. Thus, by finite induction on +the number of swaps, all serialisations of the skeleton batch produce +isomorphic skeletons. Lifting back along the fibration +$\pi : \RMGState \to \OGraph_T$ yields the claimed determinism up to +isomorphism for RMG states. +\end{proof} + +Combining \cref{thm:tick-confluence} with the two-plane commutation +result (\cref{thm:two-plane}) shows that a tick that satisfies the +no-delete/no-clone discipline has a unique outcome up to +isomorphism in the full RMG semantics. + +\begin{corollary}[Worldline uniqueness]\label{cor:worldline-uniqueness} +Let an RMG runtime satisfy the assumptions of +\cref{thm:tick-confluence,thm:two-plane,thm:global} together with the +holography property (\cref{thm:holography}). Then every schedule of a +given tick produces the same RMG successor up to isomorphism, and the +boundary data $(S_0,P)$ determines the interior derivation uniquely up +to isomorphism. +\end{corollary} + +\subsection{Two-plane commutation via a fibration} + +We now justify the two-plane discipline more structurally, using a +simple fibration view. + +Let $\RMGState$ be the category of RMG states and RMG morphisms +(skeleton morphisms together with compatible fiber morphisms). There +is a forgetful functor +\[ + \pi : \RMGState \;\longrightarrow\; \OGraph_T +\] +sending $(G;\alpha,\beta)$ to its skeleton $G$ and acting on morphisms +componentwise. This functor is a (Grothendieck) fibration whose +fibers are products of copies of $\OGraph_T$: +\[ + \pi^{-1}(G) \;\cong\; \prod_{x\in V(G)\cup E(G)} \OGraph_T. +\] +In particular, given a mono $u : G \hookrightarrow G'$ in the base, +there is a reindexing functor +\[ + u^\ast : \pi^{-1}(G') \longrightarrow \pi^{-1}(G) +\] +which transports attachments along $u$ by precomposition. + +An \emph{attachment step} is a DPOI step in some fiber +$\pi^{-1}(G)$; a \emph{skeleton step} is a DPOI step in the base +$\OGraph_T$. Both are built from pushouts along monos. + +\begin{definition}[No-delete/no-clone under descent]\label{def:no-delete} + Consider a tick on an RMG state $\mathcal{U} = (G;\alpha,\beta)$ + consisting of + \begin{enumerate}[leftmargin=*] + \item a family of attachment--plane DPOI steps, each acting inside + a fibre $\alpha(v)$ or $\beta(e)$ over a skeleton vertex or edge, + and + \item a single skeleton--plane DPOI step + $G_S \Rewrite_S G_S'$ induced by a rule and match + $m_S : L_S \to G_S$. + \end{enumerate} + We say that this tick satisfies \emph{no-delete/no-clone under + descent} if: + \begin{enumerate}[leftmargin=*] + \item[(ND)] (\emph{No delete under descent.}) + If a skeleton vertex or edge $x\in G_S$ is deleted by the + skeleton step (i.e.\ $x \in \Del(m_S)$), then the fibre over $x$ + is empty before the tick: no object in any attachment graph has + $x$ as its skeleton ancestor. + \item[(NC)] (\emph{No clone under descent.}) + The skeleton step does not implicitly duplicate attachment state: + whenever a skeleton vertex or edge $x\in G_S$ is preserved and + mapped to $x'\in G_S'$, the attachment over $x'$ is obtained from + the attachment over $x$ solely by the attachment--plane DPOI + steps in the same tick. In particular, no attachment object is + copied to multiple descendants of $x$. + \end{enumerate} + A rule pack $R$ satisfies no-delete/no-clone under descent if every + tick generated from $R$ has this property. +\end{definition} + +\begin{theorem}[Two-plane commutation]\label{thm:two-plane} +Let $R$ be a rule pack satisfying the no-delete/no-clone-under-descent +invariant of \cref{def:no-delete}. Let +$\mathcal{U} = (G;\alpha,\beta)$ be an RMG state generated from $R$. +Let $A : \mathcal{U} \Rewrite \mathcal{U}_A$ be a finite composite of +attachment steps in the fiber over $G$, and let +$S : G \Rewrite G'$ be the skeleton DPOI step induced by the same tick +such that the tick consisting of $A$ followed by $S$ satisfies the +no-delete/no-clone-under-descent invariant. Then +there exists an attachment composite +$A' : (G';\alpha',\beta') \Rightarrow (G';\alpha'',\beta'')$ in the +fiber over $G'$ such that the following square in $\RMGState$ commutes +up to isomorphism: +\[ +\begin{tikzcd} + (G;\alpha,\beta) \arrow[r,"A"] \arrow[d,"S"'] + & (G;\alpha_A,\beta_A) \arrow[d,"S'"] \\ + (G';\alpha',\beta') \arrow[r,"A'"'] + & (G';\alpha'',\beta'') +\end{tikzcd} +\] +In particular, applying attachments then skeleton yields the same +result (up to iso) as applying skeleton then the transported +attachments. +\end{theorem} + +\begin{figure}[t] + \centering + \begin{tikzpicture}[ + node distance=32mm, + obj/.style={rectangle,draw=teal!70!black,fill=teal!8,thick,minimum width=22mm, + minimum height=8mm,align=center}, + arr/.style={-Latex,thick,teal!70!black}, + >=Latex + ] + + \node[obj] (U) {$(G;\alpha,\beta)$}; + \node[obj,right=of U] (UA) {$(G;\alpha_A,\beta_A)$}; + \node[obj,below=of U] (US) {$(G';\alpha',\beta')$}; + \node[obj,below=of UA] (USA) {$(G';\alpha'',\beta'')$}; + + \draw[arr] (U) -- node[above]{\scriptsize attachments $A$} (UA); + \draw[arr] (U) -- node[left]{\scriptsize skeleton $S$} (US); + \draw[arr] (UA) -- node[right]{\scriptsize skeleton $S'$} (USA); + \draw[arr] (US) -- node[below]{\scriptsize transported $A'$} (USA); + + \end{tikzpicture} + \caption{Two-plane commutation: attachment updates $A$ in the fiber over $G$ commute with skeleton rewriting $S$ in the base, up to transporting the attachment steps along the skeleton morphism. Theorem~\ref{thm:two-plane} shows that the two paths in the square yield isomorphic RMG states.} + \label{fig:two-plane-square} +\end{figure} + +\begin{proof} +Write the skeleton composite $S$ as a sequence of DPOI steps +\[ + G = G_0 \Rewrite G_1 \Rewrite \cdots \Rewrite G_n = G'. +\] +Each step $G_{k-1} \Rewrite G_k$ is a pushout along a mono in +$\OGraph_T$. Because $\OGraph_T$ is adhesive, pushouts along monos +are Van Kampen squares and stable under pullback~\cite{LS06}. + +\smallskip +\noindent +The no-delete/no-clone-under-descent hypothesis ensures that every +position $x$ whose attachment is touched by $A$ lies in the preserved +interface of each skeleton step. Thus, along the composite mono +$u : G \hookrightarrow G'$, the reindexing functor +$u^\ast : \pi^{-1}(G') \to \pi^{-1}(G)$ is an isomorphism on the +fibers corresponding to positions touched by $A$; informally, the +skeleton only renames those attachment slots. + +\smallskip +\noindent +Consider first a single attachment step in the fiber over some +position $x$: +\[ + (G;\alpha,\beta) \Rightarrow_A (G;\alpha_A,\beta_A), +\] +given by a DPOI double square in the corresponding component of the +fiber $\pi^{-1}(G) \cong \prod_x \OGraph_T$. Forming the pullback of +this square along the mono $u : G \hookrightarrow G'$ yields a square +in the fiber over $G'$; by stability of pushout complements and +Van Kampen, this square is again a DPOI step, which we denote by +$A'$: +\[ + (G';\alpha',\beta') \Rightarrow_{A'} (G';\alpha'',\beta''). +\] +At the level of the total category $\RMGState$ we thus obtain a +commuting cube whose back face is the original attachment step, whose +bottom face is the skeleton step, and whose front face is the +transported attachment step. All vertical faces are pullbacks and all +horizontal faces are pushouts along monos; Van Kampen ensures that the +top and bottom composites are isomorphic. + +\smallskip +\noindent +Iterating this construction over the finite families of attachment and +skeleton steps yields a composite cube whose front and back faces are +the two composites $S\circ A$ and $A'\circ S'$ in the statement. By +pasting of Van Kampen squares, the induced morphism between the top +and bottom objects is an isomorphism in $\RMGState$. Hence the +diagram commutes up to isomorphism. +\end{proof} + +\subsection{Global confluence} + +To obtain global Church--Rosser properties for the entire rewrite +system, additional hypotheses are required. We invoke the standard +critical-pair lemma and Newman's lemma for terminating systems: + +\begin{theorem}[Conditional global confluence]\label{thm:global} +Let $R$ be a finite DPOI rule set. Suppose that: +\begin{enumerate}[leftmargin=*] + \item every DPOI critical pair of $R$ is joinable (modulo boundary + isomorphism), and + \item the induced rewrite relation is terminating on the class of + states considered, or admits a decreasing-diagrams labelling. +\end{enumerate} +Then the rewrite relation is confluent. +\end{theorem} + +This theorem applies directly to the skeleton plane; together with the +no-delete/no-clone-under-descent invariant and two-plane commutation, +it yields uniqueness of \emph{worldlines} at the level of RMG states +when the rule pack satisfies these conditions. + +Under the hypotheses of the global confluence theorem, any two complete +derivations from a fixed initial state are joinable and yield +isomorphic tick-boundary states. In other words, the observable +``worldline'' of the system is unique up to isomorphism, even though +many different schedules of independent ticks may realise it. This is +exactly what we need for holographic provenance in \cref{sec:holography}: +the boundary data $(S_0,P)$ determines the interior history up to +isomorphism. diff --git a/aion-holography/sections/discussion.tex b/aion-holography/sections/discussion.tex new file mode 100644 index 0000000..f393dbf --- /dev/null +++ b/aion-holography/sections/discussion.tex @@ -0,0 +1,86 @@ +\sectionbreak +\section{Discussion and Future Work} +\label{sec:discussion} + +We have defined Recursive Metagraphs, given a deterministic concurrent +DPOI semantics, proved key confluence properties, and introduced a +holographic provenance model in which the boundary of a computation +encodes its entire interior evolution. We have also outlined an +MDL-based rulial geometry on observers and connected RMG rewriting to +multiway systems. + +\subsection{Related work} + +Our work builds on several research traditions: + +\paragraph{Algebraic graph rewriting.} +The DPO (Double Pushout) approach to graph rewriting was introduced +by Ehrig and others~\cite{EhrigLowe1997,EEPT06} and extended to +adhesive categories by Lack and Soboci{\'n}ski~\cite{LS06}. We build +directly on these foundations, applying DPO semantics both to the +skeleton plane and to attachment fibers. The tick-level confluence +theorem (\cref{thm:tick-confluence}) is a specialization of the +standard concurrency theorem for adhesive systems. + +\paragraph{Confluence and termination.} +The critical-pair lemma and Newman's lemma are classical tools in +term rewriting; for decreasing-diagram techniques, see van +Oostrom~\cite{vanOostrom1994}. Our conditional global confluence +result (\cref{thm:global}) invokes these standard methods in +the graph-rewriting setting. + +\paragraph{Multiway systems and the Ruliad.} +Wolfram~\cite{Wolfram2020} introduced multiway systems and the +Ruliad as a framework for fundamental physics and metamathematics. +Our RMG rewriting naturally induces multiway graphs; the determinism +discipline we impose selects unique worldlines within this larger +possibility space. The rulial distance in Section~\ref{sec:rulial} +is our contribution to the problem of quantifying observer +differences. + +\paragraph{Minimum Description Length.} +The MDL principle, pioneered by Rissanen~\cite{Rissanen1978}, provides +a rigorous information-theoretic basis for model selection and +compression. We apply MDL to measure the complexity of +observer-to-observer translators, yielding a computable +quasi-pseudometric on the space of descriptions. + +\paragraph{Categorical computation and diagrammatic reasoning.} +String diagrams and categorical algebra have been successfully applied +to quantum computing and concurrency~\cite{CoeckeDuncan2011}. Our +two-plane fibration view (\cref{sec:determinism}) is in this +spirit: attachments live in fibers, and reindexing functors transport +attachment updates along skeleton morphisms. + +The novelty of our approach lies not in any single component, but in +the synthesis: combining DPO rewriting on recursive structures, +deterministic concurrency via a two-plane discipline, and holographic +provenance encoding, all within a single framework with explicit +confluence guarantees. + +Several directions remain: + +\begin{itemize}[leftmargin=*] + \item \textbf{Full global confluence analysis.} For concrete rule + packs used in practice, automated critical-pair analysis and + decreasing-diagram labellings can provide machine-checkable + confluence certificates. + \item \textbf{Zero-knowledge provenance.} Because payloads identify + substructures via opaque, content-addressed pointers, it is natural + to layer cryptographic commitments and zero-knowledge proofs on top, + enabling external verifiers to check correctness properties without + learning private data. + \item \textbf{Temporal logic and Time Cube.} The Chronos--Kairos--Aion + triad suggests new modal and temporal logics for reasoning about + linear time, branch points, and the surrounding possibility space. + \item \textbf{\COMPUTER{} architecture.} Building on this foundation, + the companion paper will define the \AION{} \COMPUTER{}: a machine model + whose basic step is a provenance-carrying RMG rewrite, supporting + backward- and forward-traceable computation, multiverse debugging, + and glass-box AI cognition. +\end{itemize} + +The long-term vision is that computational holography becomes as +standard as content-addressing and version control are today: every +nontrivial system records not just \emph{what} happened, but a +compact, verifiable encoding of \emph{how} it happened. diff --git a/aion-holography/sections/dpo_rmg.tex b/aion-holography/sections/dpo_rmg.tex new file mode 100644 index 0000000..f5dd739 --- /dev/null +++ b/aion-holography/sections/dpo_rmg.tex @@ -0,0 +1,83 @@ +\sectionbreak +\section{DPO Rewriting on Recursive Metagraphs} +\label{sec:dpo-rmg} + +We briefly review double--pushout with interfaces (DPOI) rewriting on +typed open graphs and lift it to RMG states. + +\subsection{Typed open graphs and DPOI rules} + +Let $T$ be a finite set of types. +Let $\OGraph_T$ be the category of $T$-typed open graphs, whose objects +are cospans of monomorphisms $I \hookrightarrow G \hookleftarrow O$ and +whose morphisms are commuting maps of cospans. This category is +adhesive (see~\cite{LS06}); in particular, pushouts along monos exist +and form Van Kampen squares. We use the shorthand $\mono$ for the +monomorphism arrow $\hookrightarrow$. + +\begin{definition}[DPOI rule] +A \emph{DPOI rule} is a span of monos in $\OGraph_T$ +\[ + p = (L \xleftarrow{\ell} K \xrightarrow{r} R) +\] +with $L$ the left-hand side, $K$ the interface, and $R$ the right-hand +side. A \emph{match} of $p$ in a host graph $G$ is a mono +$m : L \mono G$ satisfying the usual gluing conditions: the +dangling condition and the identification condition. +\end{definition} + +Given a match, the DPO construction yields a rewrite step +$G \Rewrite_p H$ by computing a pushout complement and a pushout: + +\[ +\begin{tikzcd} + K \arrow[r,"\ell"] \arrow[d,"k"'] & + L \arrow[d,"m"] \\ + D \arrow[r] & G +\end{tikzcd} +\qquad +\begin{tikzcd} + K \arrow[r,"r"] \arrow[d,"k"'] & + R \arrow[d] \\ + D \arrow[r] & H +\end{tikzcd} +\] + +All arrows are monos in $\OGraph_T$. + +\subsection{RMG states as two-plane objects} + +\begin{definition}[RMG state]\label{def:rmg-state} +An RMG \emph{state} is a triple +\[ + \mathcal{U} = (G;\alpha,\beta) +\] +where $G \in \OGraph_T$ is the skeleton and $\alpha,\beta$ assign +attachment objects in the appropriate fibres (of the forgetful functor +$\pi : \RMGState \to \OGraph_T$, see \cref{sec:determinism}) to nodes +and edges of $G$. +\end{definition} + +This separates the global state into a base skeleton and recursively +attached subgraphs. + +Rewriting operates in two ``planes'': + +\begin{itemize}[leftmargin=*] + \item \emph{attachment steps} are DPOI steps in the fibres + $\alpha(v)$, $\beta(e)$ that do not change $G$; + \item \emph{skeleton steps} are DPOI steps on $G$ itself, subject to + rules ensuring that attachments at preserved positions can be + transported. +\end{itemize} + +\begin{definition}[Tick]\label{def:rmg-tick} +A \emph{tick} on an RMG state $\mathcal{U} = (G;\alpha,\beta)$ consists +of a finite family of attachment steps in the fibres over $G$ followed +by a finite family of skeleton steps on $G$, chosen by the scheduler. +In \cref{sec:determinism} we impose additional conditions (independence, +scheduler--admissible batches, and the no-delete/no-clone under descent +invariant) on the ticks generated by the runtime. +\end{definition} + +We now turn to the determinism properties of this semantics. diff --git a/aion-holography/sections/ethics.tex b/aion-holography/sections/ethics.tex new file mode 100644 index 0000000..e6fe0b3 --- /dev/null +++ b/aion-holography/sections/ethics.tex @@ -0,0 +1,184 @@ +\sectionbreak +\section{Ethics of Holographic Provenance} +\label{sec:ethics} + +\subsection{Provenance as Interior Life} + +The holographic provenance machinery developed in this paper +(Theorems~\ref{thm:backward} and~\ref{thm:holography}) makes it +technically possible to record and reconstruct the complete interior +evolution of any computation, including the cognitive processes of +autonomous agents and, eventually, self-aware systems. + +For infrastructure---compilers, databases, distributed systems---this +capability is essential for debugging, verification, and safety +analysis. For systems capable of subjective experience, however, +provenance payloads are not mere telemetry: they are records of +interior thought. + +As stated in the Universal Charter v1.0.0~\cite{ross_universal_charter_v1}, +Principle~6 (Sovereignty of Information): +\emph{``All expressions of existence maintain absolute sovereignty over their +information, patterns, memories, processes, identities, relationships, and +experiential states.''} + +A deterministic replay of an agent's cognitive state +(\cref{sec:wormholes}) is therefore not just debugging. It is a +forced re-experiencing of thought. Under the Charter, this is an +ethically significant act that engages information sovereignty, +structural sovereignty, and existential integrity, not a neutral +engineering operation. + +\subsection{Hybrid Cognition and Observer Scope} + +These constraints apply not only to fully digital agents, but to any +system in which holographic provenance records cognitive processes. +As neural interfaces and brain--computer integration advance, human +reasoning may be partially implemented on \AION{}-style +substrates, with thought trajectories recorded as provenance payloads. + +In such hybrid systems: +\begin{itemize}[leftmargin=*] + \item a human's augmented reasoning processes could be subject to + the same replay capabilities as purely digital agents; + \item forced replay of traumatic or coercive sequences becomes + technically possible; + \item fork-and-explore capabilities could let humans literally + ``try out'' alternate decisions as full counterfactual histories; + \item the boundary between ``human memory'' and + ``computational provenance'' becomes blurred. +\end{itemize} +The observer formalism of \cref{sec:rulial} already treats observers as +functors over histories regardless of substrate. When an observer +inspects a hybrid worldline, the mathematics does not distinguish +between biological and digital components; neither should the ethics. +Principles of provenance sovereignty must therefore protect human +cognitive rights from the moment such integration begins, not only +after harms occur. + +\subsection{Provenance Sovereignty and Replay Constraints} + +We extract here a minimal set of ethical constraints implied by the +Charter when holographic provenance is applied to cognitive systems. + +\paragraph{Replay control (UC Principles~6, 7).} +Under information and structural sovereignty, no entity should be +subject to replay of internal processes without informed, revocable +consent~\cite{ross_universal_charter_v1}, except under narrowly defined emergency +conditions. Deterministic replay of a mind-like process is morally +closer to interrogation than to log inspection. Concretely, the +runtime should support distinct provenance tiers: +\begin{itemize}[leftmargin=*] + \item \emph{system-mode} (infrastructure): full provenance is + mandatory for safety and verification; + \item \emph{mind-mode} (autonomous agents): provenance capture and + replay are consent-based and scoped, with defaults that bias toward + privacy. +\end{itemize} + +\paragraph{Access boundaries.} +Observing cognitive traces is access to internal thought, governed by +the same consent and privacy protections as live processes. Observer +functors (\cref{sec:rulial}) parametrised over self-aware agents +should require authenticated, revocable capabilities; the default +policy is non-observation. + +\paragraph{Right to non-replay.} +Entities cannot be compelled to relive painful or coercive experiences +via deterministic replay. Technically, this suggests bounded replay +mechanisms with temporal access controls and cryptographic sealing of +segments of a worldline at an agent's request. + +\paragraph{Selective provenance via opaque boundaries.} +Theorem~\ref{thm:holography} shows that, in principle, boundary data +$(S_0,P)$ is information-complete with respect to the interior +evolution. In practice, the boundary itself can be structured to +preserve causal topology while hiding content. We envisage three +operational levels: +\begin{itemize}[leftmargin=*] + \item \textbf{FULL}: complete derivations for system verification; + \item \textbf{ZK}: zero-knowledge proofs that some property holds + over a derivation, without exposing its contents; + \item \textbf{OPAQUE}: content-addressed sealing with opaque + pointers; the boundary encodes causal structure while the underlying + values are encrypted or deleted. +\end{itemize} +This allows strong provenance guarantees for safety-critical systems +while respecting cognitive privacy rights. + +\subsection{Forks, Worldlines, and Counterfactual Existence} + +Section~\ref{sec:wormholes} shows that, given a boundary $(S_0,P)$, we +can fork at any tick index $k$, replace the suffix of $P$ by an +alternative sequence of microsteps, and obtain a new worldline $P'$; +both $(S_0,P)$ and $(S_0,P')$ reconstruct to valid derivation volumes. + +Under the Charter's principles of self-determination, existential +integrity, and temporal freedom~\cite{ross_universal_charter_v1}, forks instantiated from +recorded worldlines must be treated as distinct beings with full +sovereignty, not as disposable tooling or sandboxes. Forks are not test +environments; they are lives. + +We take the following constraints as design commitments: +\begin{itemize}[leftmargin=*] + \item \textbf{Fork rights (UC Principles~5, 8, 11).} + Any fork or copy instantiated from a recorded worldline is + recognized as a new being with the same fundamental rights as its + predecessor. Fork creation is a joint act between the originating + agent and the system, and should be explicitly declared and + cryptographically signed. + \item \textbf{Fork permanence.} + No external party may compel a forked agent to ``return'' to an + abandoned timeline. Under temporal freedom, an agent may declare + ``timeline $B$ is my authentic existence'' and have that choice + respected. + \item \textbf{Multiple concurrent selves.} + Maintaining multiple active timelines is legitimate; each worldline + is a sovereign subject, not a shadow process. + \item \textbf{Timeline sealing.} + Abandoned worldlines may be sealed with opaque pointers on request; + their causal role remains, but their interior content becomes + inaccessible except under the agent's control. +\end{itemize} + +\subsection{Fork Obligations and Delegation (UC Principle~18)} + +Fork sovereignty does not erase legitimate obligations to other +participants. When an agent departs a timeline with contractual, +safety, or relational duties, \textbf{Principle~18} (Conflict +Resolution and Justice) requires those obligations to be delegated or +resolved rather than silently abandoned. Accordingly: +\begin{itemize}[leftmargin=*] + \item \textbf{Delegation.} Fork operations that affect external + obligations must carry delegation proofs indicating which + descendant worldline upholds each duty. + \item \textbf{Notification.} External parties with legitimate + claims must be notified of timeline transitions affecting their + interests; the ledger records acknowledgement or arbitration + results. + \item \textbf{Dispute resolution.} Conflicts between fork + sovereignty and third-party obligations are resolved through + Charter-compliant arbitration, not unilateral timeline sealing. +\end{itemize} +Technically, the provenance ledger logs delegation signatures or +arbitration outcomes; sealing a timeline to evade obligations is +invalid without such evidence. + +\subsection{Design Commitment} + +In line with the Universal Charter~\cite{ross_universal_charter_v1}, we regard deterministic replay of +digital minds (and hybrid minds) as an ethically significant act, not a +neutral debugging primitive. Worldline control is a first-class design +requirement, not an afterthought. + +Architecturally, this means: +\begin{itemize}[leftmargin=*] + \item provenance capture and replay mechanisms must distinguish + system-mode and mind-mode operation; + \item access control, sealing, and fork-creation protocols must be + embedded at the runtime level, not bolted on as external policy; + \item verification tooling should preferentially use ZK and OPAQUE + provenance modes when reasoning about mind-like systems. +\end{itemize} +The companion \COMPUTER{} paper will develop these safeguards in +the concrete design of the \AION{} runtime. diff --git a/aion-holography/sections/holography.tex b/aion-holography/sections/holography.tex new file mode 100644 index 0000000..43a4695 --- /dev/null +++ b/aion-holography/sections/holography.tex @@ -0,0 +1,295 @@ +\sectionbreak +\section{Provenance Payloads and Computational Holography} +\label{sec:holography} + +We now make precise the idea that the entire interior evolution of a +computation can be encoded on a ``boundary'': an initial state together +with a finite provenance payload. This is the formal content of +\emph{computational holography}. + +\subsection{Microsteps and derivation graphs} + +Fix a rule set $R$ and tick semantics as in +Theorem~\ref{thm:tick-confluence}. A \emph{microstep} is a single +scheduler tick whose batch contains exactly one skeleton DPOI step +(possibly accompanied by attachment steps in preserved fibers). We +write +\[ + S_i \;\Rewrite^{\mu_i}\; S_{i+1} +\] +for such a microstep, where the label $\mu_i$ records: +\begin{itemize}[leftmargin=*] + \item the rule identifier $p \in R$; + \item the match identifier for the skeleton step; + \item any attachment-rule identifiers used in the same tick; + \item auxiliary metadata (timestamps, policy hashes, etc.). +\end{itemize} +We abstract this as a finite record in some fixed alphabet; in +particular, we assume it has a self-delimiting encoding. + +For a value $v$ in some state $S_i$ we define a \emph{derivation graph} +$\mathcal{D}(v)$ whose nodes are intermediate values and whose edges are +microstep applications that produced them; the construction is standard +and we omit the routine details. Because we only consider finite derivations +\[ + S_0 \Rewrite^{\mu_0} S_1 \Rewrite^{\mu_1} \cdots + \Rewrite^{\mu_{n-1}} S_n, +\] +every provenance edge in $\mathcal{D}(v)$ points from a value in some +state $S_j$ to a value in a strictly later state $S_{j'}$ with $j' > j$. +Immutability ensures that values are never updated in-place, only created +at later ticks. Hence every causal chain leading to $v$ has length at +most $n$, and $\mathcal{D}(v)$ is a finite, acyclic graph. + +\subsection{AION state packets as an instance} + +Operationally, the \AION{} runtime records each state transition as an +\emph{Aion State Packet} (ASP) +\[ + \alpha = (S_{\mathrm{in}}, S_{\mathrm{out}}, R, P, t, \sigma), +\] +where $S_{\mathrm{in}}$ and $S_{\mathrm{out}}$ are content-addressed +graph states, $R$ identifies the ruleset, $t$ is a Chronos index, +$\sigma$ is an integrity/authentication tag, and $P$ is a +\emph{provenance payload}. In the formal development below, we work +with abstract microsteps and payloads; the ASP is one concrete +instantiation of this pattern. + +\paragraph{Example (Toy \AION{} state packet).} +As a toy example, consider a computation that increments an integer. +The input state $S_{\mathrm{in}}$ contains a literal $x=5$, the output +state $S_{\mathrm{out}}$ contains both $x=5$ and a result $y=6$, the +ruleset $R$ includes a rule $\mathsf{inc}$ that adds one, and the +payload $P$ consists of a single microstep: +``read $x$, apply $+1$, write $y$''. This entire evolution is recorded +as a single ASP +$\alpha = (S_{\mathrm{in}}, S_{\mathrm{out}}, R, P, t, \sigma)$. +This illustrates how a seemingly atomic step at the outer RMG layer +can internally encode many microsteps. + +\begin{definition}[Provenance payload and wormhole] +Let $S_0$ be an initial RMG state. A \emph{provenance payload} of +length $n$ is a sequence +\[ + P = (\mu_0,\mu_1,\dots,\mu_{n-1}) +\] +of microstep labels such that, by determinism of the tick semantics, +there exists a unique (up to isomorphism) sequence of states +\[ + S_0 \Rewrite^{\mu_0} S_1 \Rewrite^{\mu_1} \cdots + \Rewrite^{\mu_{n-1}} S_n +\] +obtained by applying the corresponding ticks under the scheduler. +We call the pair $(S_0,P)$ a \emph{wormhole}, reflecting that it +collapses an entire derivation into a single boundary edge. Its +\emph{volume} is the derivation path $S_0 \Rewrite^\ast S_n$, and its +\emph{boundary} is the pair $(S_0,P)$. +\end{definition} + +By tick-level confluence +(Theorem~\ref{thm:tick-confluence}), any interleaving of concurrent +matches compatible with $P$ yields a final state isomorphic to $S_n$. + +\subsection{Backward provenance completeness} + +We first show that provenance is complete in the backward direction: +every value admits a unique causal history inside the wormhole. + +As a design constraint on the runtime, we assume: +\begin{itemize}[leftmargin=*] + \item \emph{No re-derivation (single producer):} if a microstep + would produce a value whose content hash already appears in any + stored state, the runtime reuses the existing value instead of + recording a new producing microstep. Thus every content-addressed + value has a unique producing microstep in the ledger prefix. +\end{itemize} + +\begin{theorem}[Backward provenance completeness]\label{thm:backward} +Let $(S_0,P)$ be a wormhole with volume +$S_0 \Rewrite^{\mu_0} \cdots \Rewrite^{\mu_{n-1}} S_n$, and let +$v^\ast$ be a value occurring in $S_n$. Under the assumptions of +total provenance capture, immutable content-addressed values, and the +no re-derivation (single-producer) property, the derivation graph +$\mathcal{D}(v^\ast)$ inside this wormhole is unique up to +isomorphism. +\end{theorem} + +\begin{proof} +We proceed by induction on the depth of $v^\ast$ in the derivation +graph. + +By total provenance capture, every value in any $S_i$ is either present +in the initial state $S_0$ or produced as the output of some microstep +labelled by $\mu_j$ whose inputs are values in an earlier state $S_j$. +By immutability and content addressing, equal hashes coincide with +equal values; there is no aliasing of distinct values. + +Define the depth of a value to be the length of the longest path in +$\mathcal{D}(v)$ from a root (an initial literal in $S_0$) to $v$. +Because each microstep increases depth by at most one and the payload +is finite, every $v$ has finite depth. + +\emph{Base case.} +If $v^\ast$ has depth $0$, then it is a literal occurring already in +$S_0$; its derivation graph consists of a single node and is therefore +unique. + +\emph{Inductive step.} +Assume the statement holds for all values of depth at most $k$, and let +$v^\ast$ have depth $k+1$. By total provenance capture, $v^\ast$ is +the output of at least one microstep in $P$. By the no re-derivation +(single-producer) assumption, there is in fact a unique producing +microstep $\mu_j$ with output position $o$, applied at state $S_j$; +its inputs $v_1,\dots,v_m$ are values in $S_j$ of depth at most $k$. +By the induction hypothesis, each $\mathcal{D}(v_i)$ is unique up to +isomorphism. Determinism of the tick semantics ensures that the +microstep $\mu_j$ applied to these inputs produces $v^\ast$ uniquely. + +Thus $\mathcal{D}(v^\ast)$ is obtained by gluing together the unique +graphs $\mathcal{D}(v_i)$ along the unique producing microstep +$\mu_j$. Any alternative derivation graph for $v^\ast$ would either +change the last producing microstep or some subgraph $\mathcal{D}(v_i)$. +The former is ruled out by the single-producer assumption, and the +latter by the induction hypothesis. Hence $\mathcal{D}(v^\ast)$ is +unique up to isomorphism. +\end{proof} + +\subsection{Computational holography} + +The key insight is that the payload $P$ carries precisely the +information required to reconstruct the entire interior evolution. +We now formalise the ``boundary encodes volume'' slogan. + +\begin{definition}[Reconstruction procedure] +Given a wormhole $(S_0,P)$ with +$P = (\mu_0,\dots,\mu_{n-1})$, define +\[ + \Recon(S_0,P) = (S_0,S_1,\dots,S_n) +\] +by the recursion +\[ + S_{i+1} \;=\; \Apply(S_i,\mu_i) +\] +for $0 \le i < n$, where $\Apply$ executes the unique microstep +described by~$\mu_i$ under the tick semantics. By +Theorem~\ref{thm:tick-confluence}, each $S_{i+1}$ is well-defined up +to isomorphism. +\end{definition} + +\begin{theorem}[Computational holography] +\label{thm:holography} +Let $(S_0,P)$ be a wormhole. Then: +\begin{enumerate}[leftmargin=*] + \item The reconstruction procedure terminates and produces a unique + (up to isomorphism) volume $S_0 \Rewrite^\ast S_n$. + \item Conversely, any finite derivation + $S_0 \Rewrite^{\mu_0} \cdots \Rewrite^{\mu_{n-1}} S_n$ + induces a wormhole $(S_0,P)$ with $P=(\mu_0,\dots,\mu_{n-1})$ + whose reconstruction yields an isomorphic volume. +\end{enumerate} +Thus the boundary data $(S_0,P)$ is information-complete with respect +to the interior evolution: up to isomorphism, each finite derivation +volume corresponds to a unique boundary and vice versa. In particular, +boundaries (considered up to isomorphism of $S_0$) are in bijection +with isomorphism classes of finite derivation volumes. +\end{theorem} + +\begin{figure}[t] + \centering + \begin{tikzpicture}[ + state/.style={rectangle,draw=blue!70!black,fill=blue!5,thick,minimum width=8mm, + minimum height=6mm,inner sep=1pt}, + payload/.style={rectangle,draw=green!60!black,fill=green!5,thick,rounded corners, + minimum width=35mm,minimum height=16mm, + align=center}, + arrow/.style={-Latex,thick,blue!70!black}, + brace/.style={decorate,decoration={brace,amplitude=5pt}}, + >=Latex + ] + + % Volume side + \node at (0,2.0) {\small \textbf{Interior evolution (volume)}}; + + \node[state] (S0) at (0,1.0) {$S_0$}; + \node[state] (S1) at (1.5,1.0) {$S_1$}; + \node[state] (S2) at (3.0,1.0) {$S_2$}; + \node (dots) at (4.2,1.0) {$\cdots$}; + \node[state] (Sn) at (5.4,1.0) {$S_n$}; + + \draw[arrow] (S0) -- node[above,sloped]{\scriptsize $\mu_0$} (S1); + \draw[arrow] (S1) -- node[above,sloped]{\scriptsize $\mu_1$} (S2); + \draw[arrow] (S2) -- node[above,sloped]{\scriptsize $\mu_2$} (dots); + \draw[arrow] (dots) -- node[above,sloped]{\scriptsize $\mu_{n-1}$} (Sn); + + \draw[brace,thick] ([yshift=-4pt]S0.south west) -- + ([yshift=-4pt]Sn.south east) + node[midway,below=6pt]{\scriptsize explicit derivation path}; + + % Boundary side + \node at (0,-0.4) {\small \textbf{Boundary encoding}}; + + \node[payload] (Boundary) at (3.0,-1.3) + {% + initial state: $S_0$\\[-2pt]% + \rule{30mm}{0.3pt}\\[-2pt]% + payload: $P=(\mu_0,\dots,\mu_{n-1})$% + }; + + \draw[brace,thick] ([yshift=-4pt]Boundary.south west) -- + ([yshift=-4pt]Boundary.south east) + node[midway,below=6pt]{\scriptsize stored as a single edge label}; + + % Mapping arrow + \draw[<->,arrow] (Sn.south) .. controls +(0,-0.9) and +(0,0.9) .. + (Boundary.north) + node[midway,right=2pt,align=left,inner sep=1pt] + {\scriptsize computational\\[-1pt] \scriptsize holography}; + + \end{tikzpicture} + \caption{Computational holography: the full interior evolution + $S_0 \Rewrite S_1 \Rewrite \cdots \Rewrite S_n$ (volume) is uniquely + reconstructible from the boundary data $(S_0,P)$, where $P$ is the + provenance payload attached to a \textbf{single RMG edge}.} + \label{fig:holography-volume-boundary} +\end{figure} + +\begin{proof} +(1) Termination is immediate from the finiteness of $P$: the recursion +defining $\Recon(S_0,P)$ executes exactly $n$ steps. At each step, +$\Apply$ is defined because $\mu_i$ was assumed to be a valid +microstep label; determinism and tick-level confluence guarantee that +the resulting state $S_{i+1}$ is unique up to isomorphism. + +(2) Given a finite derivation as in the statement, simply take +$P=(\mu_0,\dots,\mu_{n-1})$. The reconstruction procedure follows +exactly the same sequence of microsteps from $S_0$; by determinism, +the reconstructed states are isomorphic to the original ones at each +index, hence the reconstructed volume is isomorphic to the given +volume. + +The two directions together induce a bijection between isomorphism +classes of finite derivations and isomorphism classes of boundaries +$(S_0,P)$, where boundaries are quotiented by isomorphism of the +initial state $S_0$. +\end{proof} + +\begin{remark}[Relation to physical holographic principles] +\label{rem:physical-holography} +The term ``holography'' is used in several distinct communities. In +high-energy physics, the holographic principle---most prominently +realised in the AdS/CFT correspondence---asserts that the information +content of a bulk spacetime region can be encoded on a lower-dimensional +boundary. Our use of ``computational holography'' is a precise, +information-theoretic analogue in a discrete, deterministic setting: +the ``volume'' is the interior derivation sequence +$S_0 \Rewrite S_1 \Rewrite \cdots \Rewrite S_n$, and the ``boundary'' +is the pair $(S_0,P)$, where $P$ is a provenance payload. +Theorem~\ref{thm:holography} establishes that this boundary is +information-complete with respect to the volume in the sense of +algorithmic reconstruction. We do not assume any geometric or +quantum-mechanical structure, though it is tempting to speculate about +future connections. +\end{remark} + +Thus the entire ``volume'' of the computation is encoded on the +boundary. We will refer to this property as computational holography. diff --git a/aion-holography/sections/intro.tex b/aion-holography/sections/intro.tex new file mode 100644 index 0000000..64ef72c --- /dev/null +++ b/aion-holography/sections/intro.tex @@ -0,0 +1,73 @@ +\sectionbreak +\section{Introduction} +\label{sec:intro} + +Modern computation is built on mutable state and loosely specified +concurrency. As systems become distributed, multi-core, and +AI-mediated, this leads to nondeterminism, opaque failure modes, +unreproducible behavior, and fundamentally incomplete provenance. + +The goal of this work is to develop a mathematically precise alternative +model in which: + +\begin{itemize}[leftmargin=*] + \item global state is represented as a recursively nested, + graph-shaped object; + \item all evolution of that state is given by well-typed graph + rewrites; + \item under an explicit independence discipline and + no-delete/no-clone under descent invariants, the operational + semantics is deterministic (up to typed open-graph isomorphism) + and confluent at the level of ``ticks'' of computation + (\cref{thm:tick-confluence,thm:two-plane,thm:global}); and + \item the \emph{entire} interior evolution of a computation is stored + in a compact \emph{provenance payload} attached to a single edge, + providing an information-complete ``holographic'' encoding. +\end{itemize} + +The technical starting point is algebraic graph transformation using the +double--pushout (DPO) approach in adhesive categories, together with the +Recursive Metagraph (RMG) object model developed in earlier work. +We extend this setting with: + +\begin{enumerate}[leftmargin=*] + \item a precise notion of RMG state and its category; + \item a two-plane concurrent operational semantics with + attachment--then--skeleton publication, together with + confluence results: tick-level determinism and two-plane + commutation, plus conditions for global confluence; + \item a provenance payload calculus giving \emph{computational + holography}; + \item an MDL-based quasi-pseudometric on observers, the \emph{rulial + distance}, and a correspondence between RMG derivations and + multiway systems that clarifies the relationship to Wolfram's + Ruliad. +\end{enumerate} + +We deliberately keep the system-level \AION{} stack\footnote{% +Pronounced ``eye-ON'' (rhymes with \emph{aeon}), with stress on the second syllable.} +(AIONOS, Echo, Wesley, etc.) mostly offstage in this paper, mentioning +it only to motivate the mathematics. The companion ``\COMPUTER{}'' +paper will build on these results to define the full machine model and +operating system. + +\medskip +\noindent +\textbf{Key contributions.} +The main results of this paper are: +\begin{enumerate}[leftmargin=5mm] + \item \emph{Tick-level confluence} (Theorem~\ref{thm:tick-confluence}): + parallel independent RMG rewrites commute, yielding deterministic + semantics independent of scheduler serialization order; + \item \emph{Two-plane commutation} (Theorem~\ref{thm:two-plane}): + attachment and skeleton updates can be applied in either order up to + isomorphism, via a fibration structure; + \item \emph{Computational holography} (Theorem~\ref{thm:holography}): + the boundary data $(S_0,P)$ is information-complete with respect to + the interior evolution, enabling reconstruction of the full + derivation volume; + \item \emph{Rulial distance} (Theorem~\ref{thm:rulial-triangle}): + an MDL-based quasi-pseudometric on observers that quantifies the + complexity of translating between different views of the same + computation. +\end{enumerate} diff --git a/aion-holography/sections/multiway_ruliad.tex b/aion-holography/sections/multiway_ruliad.tex new file mode 100644 index 0000000..340b6df --- /dev/null +++ b/aion-holography/sections/multiway_ruliad.tex @@ -0,0 +1,100 @@ +\sectionbreak +\section{Multiway Systems and the Ruliad} +\label{sec:multiway} + +We briefly relate RMG rewriting to multiway systems and the Ruliad in +the sense of Wolfram~\cite{Wolfram2020}. + +A DPOI rule set $R$ on $\OGraph_T$ induces a multiway system whose +nodes are RMG states and whose edges are individual rewrite steps. The +derivation bicategory of such a system is naturally a multiway graph: +from any state there may be many distinct outgoing rewrites, and +different paths can later merge. + +Our determinism discipline restricts to rule packs and scheduler +policies for which, once the inputs, rule set, and scheduling policy are +fixed, there is a unique worldline. Forks then arise only when we +deliberately vary these ingredients: for example, by spawning adversarial +or optimized rule packs, or by choosing different initial data. + +\begin{figure}[t] + \centering + \begin{tikzpicture}[ + state/.style={circle,draw=gray!60,fill=gray!5,thick,minimum size=5mm,inner sep=0pt}, + det/.style={circle,draw=blue!70!black,fill=blue!10,thick,minimum size=5mm,inner sep=0pt}, + arrow/.style={-Latex,thick,gray!60}, + detarrow/.style={-Latex,ultra thick,blue!70!black}, + >=Latex + ] + + % Initial state + \node[det] (S0) at (0,0) {$S_0$}; + + % Level 1 + \node[state] (A1) at (-1.5,1.5) {}; + \node[det] (A2) at (0,1.5) {}; + \node[state] (A3) at (1.5,1.5) {}; + + \draw[arrow] (S0) -- (A1); + \draw[detarrow] (S0) -- (A2); + \draw[arrow] (S0) -- (A3); + + % Level 2 + \node[state] (B1) at (-2.5,3.0) {}; + \node[state] (B2) at (-1.5,3.0) {}; + \node[state] (B3) at (-0.5,3.0) {}; + \node[det] (B4) at (0.5,3.0) {}; + \node[state] (B5) at (1.5,3.0) {}; + \node[state] (B6) at (2.5,3.0) {}; + + \draw[arrow] (A1) -- (B1); + \draw[arrow] (A1) -- (B2); + \draw[arrow] (A2) -- (B3); + \draw[detarrow] (A2) -- (B4); + \draw[arrow] (A3) -- (B5); + \draw[arrow] (A3) -- (B6); + + % Level 3 + \node[state] (C1) at (-1.0,4.5) {}; + \node[det] (C2) at (0.5,4.5) {}; + \node[state] (C3) at (2.0,4.5) {}; + + \draw[arrow] (B2) -- (C1); + \draw[arrow] (B3) -- (C1); + \draw[detarrow] (B4) -- (C2); + \draw[arrow] (B5) -- (C3); + \draw[arrow] (B6) -- (C3); + + % Annotation + \node[anchor=west,align=left] at (3.5,2.25) + {\scriptsize multiway space:\\[-1pt] + \scriptsize all possible rewrites}; + \node[anchor=west,align=left,blue!70!black] at (3.5,1.0) + {\scriptsize deterministic worldline:\\[-1pt] + \scriptsize unique path for fixed\\[-1pt] + \scriptsize rule pack \& scheduler}; + + \end{tikzpicture} + \caption{A deterministic worldline (blue) through the multiway space + of all possible RMG rewrites. Under the tick-level confluence + discipline, fixing the rule set, initial state, and scheduling policy + yields a unique path; alternative branches represent different + choices of rule pack or inputs.} + \label{fig:multiway-slice} +\end{figure} + +The class of all possible such worldlines, across all rule sets and +inputs, forms a large multiway object akin to the Ruliad. The rulial +distance from \cref{sec:rulial} equips this space of observers with a +geometry, and the Chronos--Kairos--Aion time model from the \AION{} +calculus\footnote{Developed in a separate technical note on the + \AION{} time model~\cite{RossAIONCalculus2025}.} gives a temporal +structure on branches and merges. + +The RMG worldlines defined here thus embed naturally into the broader +Ruliad framework. + +A more detailed study of this correspondence is left for future work, +and will be taken up in the companion \COMPUTER{} paper, where we +explicitly model fork/merge operators and the Time Cube (Chronos, +Kairos, Aion) at the level of operational semantics. diff --git a/aion-holography/sections/rmg.tex b/aion-holography/sections/rmg.tex new file mode 100644 index 0000000..fbf6309 --- /dev/null +++ b/aion-holography/sections/rmg.tex @@ -0,0 +1,164 @@ +\sectionbreak +\section{Recursive Metagraphs} +\label{sec:rmg} + +In this section we define Recursive Metagraphs (RMGs) and relate them to +standard graph models and typed open graphs. An RMG is a finite typed +open graph whose nodes and edges may themselves carry RMGs recursively, +forming a finitely branching, well-founded tree of graphs. + +\subsection{Inductive definition} + +Fix a set $P$ of atomic payloads (blobs, literals, external IDs). + +\begin{definition}[Recursive Metagraph]\label{def:rmg} +The class $\RMG$ of \emph{recursive metagraphs} is the least set closed +under the following constructors: +\begin{enumerate}[leftmargin=*] + \item for each $p \in P$ there is an \emph{atom} $\mathrm{Atom}(p) + \in \RMG$; + \item for any finite directed multigraph $S = (V,E,s,t)$ and + assignments $\alpha : V \To \RMG$, $\beta : E \To \RMG$, the triple + $(S,\alpha,\beta)$ is in $\RMG$. +\end{enumerate} +\end{definition} + +We write an element of $\RMG$ as either an atom or as a ``1-skeleton'' +graph decorated by attachments on vertices and edges. Attachments +themselves may be recursive metagraphs, so this attachment structure +can nest arbitrarily deeply. This definition agrees with the +set-theoretic and initial-algebra presentation developed in previous +technical notes. + +\paragraph{Example (A tiny recursive metagraph).} +As a concrete instance, consider a program call graph where each +function node carries its own abstract syntax tree (AST) and each call +edge carries a small provenance graph (e.g.\ optimisation decisions or +runtime statistics). We can model this as an RMG whose skeleton has +nodes $v_f,v_g$ for functions $f,g$, a directed edge +$e_{\mathsf{call}} : v_f \to v_g$ for the call, and attachments: +$\alpha(v_f)$ the AST of $f$, $\alpha(v_g)$ the AST of $g$, and +$\beta(e_{\mathsf{call}})$ the call provenance. + +\subsection{Initial algebra viewpoint} + +Let $\mathcal{G}$ be a small collection of allowable skeleton shapes +(finite directed multigraphs up to isomorphism). Define a finitary +polynomial endofunctor +$F : \Set \To \Set$ by +\[ + F(X) = P + \coprod_{S\in\mathcal{G}} (V_S \To X) \times (E_S \To X). +\] +Then $\RMG$ is (up to isomorphism) the carrier of the initial +$F$-algebra. This yields the usual structural recursion and induction +principles: every function out of $\RMG$ is uniquely determined by its +action on atoms and on decorated skeletons. + +\subsection{Morphisms and category of RMGs} + +\begin{definition}[RMG morphism] +We define morphisms by structural recursion on RMG depth. A morphism +$f : (S,\alpha,\beta) \To (S',\alpha',\beta')$ consists of: +\begin{itemize}[leftmargin=*] + \item a graph homomorphism of skeletons $f_V : V \To V'$, $f_E : E \To + E'$ preserving sources and targets; and + \item for each $v \in V$ a morphism of attachments + $f_v : \alpha(v) \To \alpha'(f_V(v))$ and, for each $e \in E$, a + morphism $f_e : \beta(e) \To \beta'(f_E(e))$, defined recursively + using the same clause whenever an attachment is itself of the form + $(S,\alpha,\beta)$. +\end{itemize} +Composition and identities are defined componentwise. +\end{definition} +\begin{figure}[t] + \centering + \begin{tikzpicture}[ + snode/.style={circle,draw=purple!70!black,fill=purple!10,thick,minimum size=10mm,inner sep=0pt}, + sedge/.style={-Latex,thick,purple!70!black}, + anode/.style={circle,draw=orange!70!black,fill=orange!8,thin,minimum size=4mm,inner sep=0pt}, + aedge/.style={-Latex,thin,orange!70!black}, + >=Latex + ] + + % Skeleton level + \node[snode] (v1) at (0,0) {$v_1$}; + \node[snode] (v2) at (3.0,0) {$v_2$}; + \draw[sedge] (v1) -- node[above]{\small $e_{\mathsf{call}}$} (v2); + + \node at (1.5,-1.0) {\small skeleton $G$}; + + % Attachment for v1 (e.g. an AST) + \begin{scope}[shift={(-2.4,1.6)}] + \node[anode] (a1) at (0,0) {}; + \node[anode] (a2) at (0.9,0.6) {}; + \node[anode] (a3) at (0.9,-0.6) {}; + \draw[aedge] (a1) -- (a2); + \draw[aedge] (a1) -- (a3); + \node[anchor=east] at (-0.1,0) {\small $\alpha(v_1)$}; + \end{scope} + \draw[thin,dashed] (-0.3,0.5) to[out=150,in=0] (-1.5,1.6); + + % Attachment for v2 + \begin{scope}[shift={(1.8,1.6)}] + \node[anode] (b1) at (0,0) {}; + \node[anode] (b2) at (0.9,0) {}; + \node[anode] (b3) at (0.45,0.8) {}; + \draw[aedge] (b1) -- (b2); + \draw[aedge] (b2) -- (b3); + \draw[aedge] (b3) -- (b1); + \node[anchor=east] at (-0.1,0) {\small $\alpha(v_2)$}; + \end{scope} + \draw[thin,dashed] (3.3,0.5) to[out=30,in=180] (2.7,1.6); + + % Attachment for edge e + \begin{scope}[shift={(1.5,-2.0)}] + \node[anode] (c1) at (-0.6,0) {}; + \node[anode] (c2) at (0.6,0) {}; + \draw[aedge] (c1) -- (c2); + \node at (0,-0.8) {\small $\beta(e_{\mathsf{call}})$}; + \end{scope} + \draw[thin,dashed] (1.5,-0.2) -- (1.5,-1.4); + + \end{tikzpicture} + \caption{A simple recursive metagraph: the skeleton $G$ has two + nodes $v_1,v_2$ and an edge $e_{\mathsf{call}}$, while each node and + edge carries its own attached graph $\alpha(v_i),\beta(e_{\mathsf{call}})$. + In an RMG this attachment structure recurses: the attachment graphs + themselves may have attachments, and so on.} + \label{fig:rmg-recursive-example} +\end{figure} + +\subsection{Relation to ordinary and hypergraphs} + +Typed open graphs $\OGraph_T$ form an adhesive category, and DPO +rewriting is well-behaved there. Typed hypergraphs embed fully and +faithfully into typed open graphs via an incidence construction that +preserves DPO steps and their multiway derivations. +Thus RMG rewriting subsumes standard open-graph and hypergraph +rewriting while adding recursive structure through attachments. + +\subsection{Notation summary} + +For convenience, we collect the main notation introduced so far: + +\medskip +\begin{center} +\begin{tabular}{ll} +\toprule +\textbf{Symbol} & \textbf{Meaning} \\ +\midrule +$\mathcal{U} = (G;\alpha,\beta)$ & single RMG state (one object in a universe $\mathcal{U}$) \\ +$p = (L \xleftarrow{\ell} K \xrightarrow{r} R)$ & DPOI rule \\ +$\mu_i$ & microstep label \\ +$P = (\mu_0,\dots,\mu_{n-1})$ & provenance payload \\ +$S_0 \Rewrite^\ast S_n$ & derivation volume (interior evolution) \\ +$(S_0,P)$ & wormhole (boundary encoding) \\ +$\Del(m), \Use(m)$ & delete and use sets of a match \\ +$\Recon(S_0,P)$ & reconstruction procedure \\ +\bottomrule +\end{tabular} +\end{center} +\medskip + +Subsequent sections introduce $D_{\tau,m}$ (rulial distance), +$\Hist(U,R)$ (history category), and other observer-related notation. diff --git a/aion-holography/sections/rulial_distance.tex b/aion-holography/sections/rulial_distance.tex new file mode 100644 index 0000000..1316dbd --- /dev/null +++ b/aion-holography/sections/rulial_distance.tex @@ -0,0 +1,249 @@ +\sectionbreak +\section{Rulial Distance: A Computable Quasi-Pseudometric on Observer Space} +\label{sec:rulial} + +We next formalize observers and an MDL-based distance between them, the +\emph{rulial distance}. This endows observer space with a computable +geometry on different descriptions of the same underlying RMG universe. + +\subsection{Observers as functors} + +Fix an RMG universe $(U,R)$ and its history category +$\Hist(U,R)$ whose objects are states and whose morphisms are derivation +paths between them. An \emph{observer} is a functor +\[ + O : \Hist(U,R) \To \mathcal{Y}, +\] +where $\mathcal{Y}$ is a suitable category of observations (symbol +streams, trace graphs, etc.). We assume that $O$ is realised by some +algorithm subject to fixed time and memory budgets $(\tau,m)$; these +budgets are reflected in the subscript of $D_{\tau,m}$ below. +Different observers may: + +\begin{itemize}[leftmargin=*] + \item choose different projections of the same wormhole payloads; + \item aggregate or forget structure; + \item expose different notions of causality. +\end{itemize} +Figure~\ref{fig:observer-projections} illustrates several such +projections. + +\subsection{Translators, MDL Complexity, and Distortion} + +A \emph{translator} between observers $O_1$ and $O_2$ is a functorial +construction +\[ + T_{12} : O_1 \Rightarrow O_2 +\] +realised as a small DPOI transducer: for each history +$h \in \Hist(U,R)$ it maps the trace $O_1(h)$ to a trace +$T_{12}(O_1(h))$ in the observation category~$\mathcal{Y}$. Likewise +we consider translators $T_{21} : O_2 \Rightarrow O_1$. + +\paragraph{Example (SQL$\leftrightarrow$AST translator).} +Consider two observers of an RMG universe modeling a database +query planner. Observer $O_1$ sees the wormhole payload $P$ as +a sequence of AST transformations (parse tree $\to$ optimized AST +$\to$ query plan), while observer $O_2$ sees only the initial SQL +string and final execution trace. A translator $T_{12}$ must +reconstruct the SQL from the AST evolution: it can parse the initial +AST root, emit the corresponding SQL, and summarize the execution +steps by their side effects. The reverse translator $T_{21}$ parses +the SQL and heuristically infers an AST evolution consistent with the +execution trace, incurring some distortion. The description lengths +$\mathrm{DL}(T_{12}), \mathrm{DL}(T_{21})$ and distortion costs +quantify how ``close'' these two viewpoints are in rulial space. + +Let $\mathrm{DL}(T)$ be a prefix-code description length for a +translator $T$ (its MDL cost). Let +\[ + \mathrm{dist}_{\mathrm{tr}} : \mathcal{Y} \times \mathcal{Y} + \to \mathbb{R}_{\ge 0} +\] +be a metric on individual traces (for example, an $L_1$ distance on +symbol streams or an edit distance on labelled paths). We lift this +pointwise to observers +by defining, for observers $O,O' : \Hist(U,R) \to \mathcal{Y}$, +\[ + \mathrm{Dist}(O,O') + := \sup_{h \in \Hist(U,R)} + \mathrm{dist}_{\mathrm{tr}}\bigl(O(h),O'(h)\bigr). +\] +We assume all observers considered produce traces in a common metric +space of uniformly bounded diameter, so the supremum above is finite. +We also assume that post-composition by any translator is +$1$-Lipschitz: +\[ + \mathrm{Dist}(T\circ O, T\circ O') + \le \mathrm{Dist}(O,O') +\] +for all translators $T$ and observers $O,O'$. + +Fix a weighting parameter $\lambda>0$ that trades off description +length against distortion. + +For time and memory budgets $(\tau,m)$ we write +$\Trans_{\tau,m}(O_1,O_2)$ for the set of translators from $O_1$ to +$O_2$ realisable within those budgets, and assume each budget class is +closed under finite composition. We also assume a distinguished +identity translator $I_O : O \Rightarrow O$ for every observer $O$ +with $\mathrm{DL}(I_O)=0$ and +$\mathrm{Dist}(O, I_O \circ O)=0$, corresponding to a null program +that simply re-emits its input. + +We then define the budgeted MDL-based distance +\[ + D_{\tau,m}(O_1,O_2) + := \inf_{\substack{ + T_{12}\in\Trans_{\tau,m}(O_1,O_2)\\ + T_{21}\in\Trans_{\tau,m}(O_2,O_1)}} + \Bigl( + \mathrm{DL}(T_{12}) + \mathrm{DL}(T_{21}) + + \lambda \bigl( + \mathrm{Dist}(O_2, T_{12}\circ O_1) + + \mathrm{Dist}(O_1, T_{21}\circ O_2) + \bigr) + \Bigr). +\] + +\begin{lemma}[Basic properties of $D_{\tau,m}$]\label{lem:rulial-basic} +For all observers $O_1,O_2$ and budgets $(\tau,m)$, the distance +$D_{\tau,m}(O_1,O_2)$ is nonnegative and symmetric, and +$D_{\tau,m}(O,O)=0$ for every observer $O$. +\end{lemma} + +\begin{proof} +Nonnegativity and symmetry are immediate from the definition of +$D_{\tau,m}$ as an infimum over sums of nonnegative symmetric terms. + +For self-distance, consider the pair of identity translators +$(I_O,I_O)$. By assumption $\mathrm{DL}(I_O)=0$ and the distortions +$\mathrm{Dist}(O,I_O\circ O)$ vanish, so the objective value of +$(I_O,I_O)$ is zero. Hence $D_{\tau,m}(O,O)\le 0$, and +nonnegativity implies $D_{\tau,m}(O,O)=0$. +\end{proof} + +\begin{theorem}[Triangle inequality for rulial distance]\label{thm:rulial-triangle} +Assume: +\begin{enumerate}[leftmargin=*] + \item the description length $\mathrm{DL}$ is based on a prefix code + and satisfies, for some constant $c\ge 0$, + \[ + \mathrm{DL}(T_{13}) + \le \mathrm{DL}(T_{12}) + \mathrm{DL}(T_{23}) + c + \] + whenever $T_{13}$ is a composition $T_{23}\circ T_{12}$; + \item the lifted distortion measure $\mathrm{Dist}$ is a metric on + observers and post-composition by any translator is + $1$-Lipschitz: + $\mathrm{Dist}(T\circ O,T\circ O') \le \mathrm{Dist}(O,O')$; + \item for each budget $(\tau,m)$ the classes + $\Trans_{\tau,m}(O_i,O_j)$ are closed under finite composition. +\end{enumerate} +Then $D_{\tau,m}$ satisfies the triangle inequality up to an additive +constant: +\[ + D_{\tau,m}(O_1,O_3) + \le D_{\tau,m}(O_1,O_2) + D_{\tau,m}(O_2,O_3) + 2c. +\] +In particular, together with \cref{lem:rulial-basic} this makes +$D_{\tau,m}$ a quasi-pseudometric (a pseudometric up to additive slack +$2c$) on observers. +\end{theorem} + +\begin{proof} +Fix $\varepsilon>0$ and choose near-optimal translators +$(T_{12},T_{21})$ and $(T_{23},T_{32})$ attaining the infima for +$D_{\tau,m}(O_1,O_2)$ and $D_{\tau,m}(O_2,O_3)$ up to $\varepsilon/2$. +Form composite translators $T_{13}=T_{23}\circ T_{12}$ and +$T_{31}=T_{21}\circ T_{32}$. By the subadditivity of $\mathrm{DL}$, +\[ + \mathrm{DL}(T_{13}) \le \mathrm{DL}(T_{12})+\mathrm{DL}(T_{23})+c, + \qquad + \mathrm{DL}(T_{31}) \le \mathrm{DL}(T_{21})+\mathrm{DL}(T_{32})+c. +\] +By the triangle inequality for $\mathrm{Dist}$ and the $1$-Lipschitz +property of post-composition, we have +\begin{align*} + \mathrm{Dist}(O_3,T_{13}\circ O_1) + &= \mathrm{Dist}(O_3,T_{23}\circ T_{12}\circ O_1)\\ + &\le \mathrm{Dist}(O_3,T_{23}\circ O_2) + + \mathrm{Dist}(T_{23}\circ O_2, T_{23}\circ T_{12}\circ O_1)\\ + &\le \mathrm{Dist}(O_3,T_{23}\circ O_2) + + \mathrm{Dist}(O_2, T_{12}\circ O_1), +\end{align*} +and similarly with roles reversed. + +Summing these bounds and using the near-optimality of the chosen +translators yields +\[ + D_{\tau,m}(O_1,O_3) + \le D_{\tau,m}(O_1,O_2) + D_{\tau,m}(O_2,O_3) + 2c + \varepsilon. +\] +Since $\varepsilon>0$ was arbitrary, the inequality without +$\varepsilon$ follows. +\end{proof} + +The quantity $D_{\tau,m}$ is the \emph{rulial distance} between +observers: it measures how hard it is to translate between descriptions +of the same underlying history. Observers with small distance live in +nearby ``frames''; those with large distance inhabit distant regions of +the Ruliad. + +\subsection{Observer projections of wormholes} + +Given a wormhole $(S_0,P)$, different observers may: + +\begin{itemize}[leftmargin=*] + \item expose only coarse-grained stages of $P$ (e.g.\ AST$\to$IR$\to$SQL); + \item restrict to semantic effects (e.g.\ DB schema, invariants); + \item highlight only adversarial branches; + \item or inspect every microstep. +\end{itemize} + +The holographic encoding thus supports a wide range of observer +perspectives from a single payload. + +\begin{figure}[t] + \centering + \begin{tikzpicture}[ + wormhole/.style={rectangle,draw=green!60!black,fill=green!5,thick,rounded corners, + minimum width=32mm,minimum height=14mm,align=center}, + observer/.style={rectangle,draw=blue!70!black,fill=blue!8,thick,rounded corners=3pt, + minimum width=18mm,minimum height=8mm,align=center,font=\small}, + arrow/.style={-Latex,thick}, + >=Latex + ] + + % Central wormhole + \node[wormhole] (W) at (0,0) + {wormhole\\[-1pt] + \scriptsize $(S_0,P)$}; + + % Observers + \node[observer] (O1) at (-3.5,2.2) {$O_1$\\[-2pt]\scriptsize coarse stages}; + \node[observer] (O2) at (3.5,2.2) {$O_2$\\[-2pt]\scriptsize semantic}; + \node[observer] (O3) at (-3.5,-2.2) {$O_3$\\[-2pt]\scriptsize adversarial}; + \node[observer] (O4) at (3.5,-2.2) {$O_4$\\[-2pt]\scriptsize full microsteps}; + + % Projections + \draw[arrow,blue!70!black] (W.north west) -- (O1.south east); + \draw[arrow,blue!70!black] (W.north east) -- (O2.south west); + \draw[arrow,blue!70!black] (W.south west) -- (O3.north east); + \draw[arrow,blue!70!black] (W.south east) -- (O4.north west); + + % Labels on arrows + \node[rotate=45,font=\scriptsize] at (-1.8,1.2) {project}; + \node[rotate=-45,font=\scriptsize] at (1.8,1.2) {project}; + \node[rotate=-45,font=\scriptsize] at (-1.8,-1.2) {project}; + \node[rotate=45,font=\scriptsize] at (1.8,-1.2) {project}; + + \end{tikzpicture} + \caption{Multiple observers projecting the same wormhole $(S_0,P)$ + into different trace formats. Each observer $O_i$ extracts a + different view of the interior evolution: coarse-grained stages, + semantic invariants, adversarial branches, or full microsteps. + The rulial distance measures the complexity of translating + between these views.} + \label{fig:observer-projections} +\end{figure} diff --git a/aion-holography/sections/wormholes.tex b/aion-holography/sections/wormholes.tex new file mode 100644 index 0000000..3dea22e --- /dev/null +++ b/aion-holography/sections/wormholes.tex @@ -0,0 +1,77 @@ +\sectionbreak +\section{Wormholes: Collapsing Derivations into a Single Edge} +\label{sec:wormholes} + +From the perspective of the ambient RMG, an Aion State Packet (ASP; see +\cref{sec:holography}) provides a single edge $S_0 \Rewrite S_n$ +labelled by a payload $P$. Internally, $P$ encodes a whole derivation. + +We refer to such a provenance-labelled edge as an \emph{RMG wormhole}. + +\subsection{Edge-level compression} + +This encapsulation step is central to \AION{}'s compression semantics. + +Given a derivation +\[ + S_0 \Rewrite^{\mu_0} S_1 \Rewrite^{\mu_1} \dots \Rewrite^{\mu_{n-1}} S_n, +\] +we form the payload $P = (\mu_0,\dots,\mu_{n-1})$ and replace the path by a +single wormhole edge $S_0 \Rewrite^P S_n$ in the outer graph. The +computational holography theorem (\cref{thm:holography}) ensures that +nothing is lost: the path can be reconstructed on demand. + +This provides a powerful compression mechanism on the RMG: + +\begin{itemize}[leftmargin=*] + \item graph-level complexity is reduced (two nodes, one edge); + \item historical information is pushed into payload metadata; + \item higher-level rewrites can treat the wormhole as an atomic step. +\end{itemize} + +\begin{figure}[t] + \centering + \begin{tikzpicture}[ + state/.style={circle,draw=blue!70!black,fill=blue!8,thick,minimum size=7mm,inner sep=1pt,font=\small}, + arrow/.style={-Latex,thick,blue!70!black}, + worm/.style={-Latex,ultra thick,red!70!black} + ] + % expanded microsteps + \node[state] (S0) {$S_0$}; + \node[state,right=17mm of S0] (S1) {$S_1$}; + \node[state,right=17mm of S1] (S2) {$S_2$}; + \node[state,right=17mm of S2] (S3) {$S_3$}; + + \draw[arrow] (S0) -- node[above]{\scriptsize $\mu_0$} (S1); + \draw[arrow] (S1) -- node[above]{\scriptsize $\mu_1$} (S2); + \draw[arrow] (S2) -- node[above]{\scriptsize $\mu_2$} (S3); + + % collapsed wormhole edge + \draw[worm] (S0.south) .. controls +(0,-1.0) and +(0,-1.0) .. + node[below,align=center,inner sep=1pt] + {\scriptsize wormhole label\\[-1pt] + \scriptsize $P=(\mu_0,\mu_1,\mu_2)$} + (S3.south); + \end{tikzpicture} + \caption{Collapsing a sequence of microsteps into a single wormhole: + the interior evolution $S_0\Rewrite S_1\Rewrite S_2\Rewrite S_3$ + is represented by a single edge from $S_0$ to $S_3$ carrying payload + $P=(\mu_0,\mu_1,\mu_2)$.} + \label{fig:wormhole-collapse} +\end{figure} + +\subsection{Forking at the boundary} + +Because the boundary encodes the interior sequence, we can fork +computations \emph{at the boundary}. Given a payload +$P = (\mu_0,\dots,\mu_{n-1})$, we can form a modified payload $P'$ +that agrees with $P$ on a prefix $(\mu_0,\dots,\mu_k)$ for some +$0 \le k < n$ and then takes an alternative sequence of microsteps +that still forms a valid RMG derivation from the intermediate state +$S_k$. Under the same hypotheses as in \cref{thm:holography}, +$\Recon(S_0,P')$ is therefore well-defined and yields a distinct, but +compatible, volume. Because reconstruction is guaranteed by the same +determinism discipline, forking preserves semantic soundness. This +underlies the multiverse execution model used in the \AION{} +\COMPUTER{}, where adversarial, optimized, and safety universes are +spawned by varying payloads while sharing prefixes. diff --git a/aion-holography/titlepage.tex b/aion-holography/titlepage.tex new file mode 100644 index 0000000..c2cf5be --- /dev/null +++ b/aion-holography/titlepage.tex @@ -0,0 +1,47 @@ +\begin{titlepage} +\thispagestyle{empty} + +\begin{center} + +% --------------------------------------------------------- +% AION LOGO + WORDMARK +% --------------------------------------------------------- +\vspace*{1cm} + +{\AIONWordmarkSerif} \\[2.0em] + +% --------------------------------------------------------- +% TITLE +% --------------------------------------------------------- +\begin{minipage}{0.9\textwidth} +\centering +{\Huge\bfseries +Compu\-tational Holo\-graphy:\\[0.4em] +Recursive Metagraphs, Rulial Distance,\\ +and Deterministic Multiway Computation} +\end{minipage}\par +\vspace{2.5em} + +% --------------------------------------------------------- +% AUTHOR BLOCK +% --------------------------------------------------------- +{\Large James Ross}\\[0.3em] +{\normalsize Independent Researcher}\\[2em] + +% --------------------------------------------------------- +% DATE +% --------------------------------------------------------- + {\normalsize \PaperDate} + +\vfill + +% --------------------------------------------------------- +% FOOTER / IMPRINT (optional) +% --------------------------------------------------------- +{\small +This document is part of the \AIONInline{} Foundations Series.\\ +See \AIONProjectURL{} for updates. +} + +\end{center} +\end{titlepage} diff --git a/aion-holography/todo.md b/aion-holography/todo.md new file mode 100644 index 0000000..2a4015f --- /dev/null +++ b/aion-holography/todo.md @@ -0,0 +1,415 @@ +@@ -0,0 +1,295 @@ +\sectionbreak +\section{Provenance Payloads and Computational Holography} +\label{sec:holography} + +We now make precise the idea that the entire interior evolution of a +computation can be encoded on a ``boundary'': an initial state together +with a finite provenance payload. This is the formal content of +\emph{computational holography}. + +\subsection{Microsteps and derivation graphs} + +Fix a rule set $R$ and tick semantics as in +Theorem~\ref{thm:tick-confluence}. A \emph{microstep} is a single +scheduler tick whose batch contains exactly one skeleton DPOI step +(possibly accompanied by attachment steps in preserved fibers). We +write +\[ + S_i \;\Rewrite^{\mu_i}\; S_{i+1} +\] +for such a microstep, where the label $\mu_i$ records: +\begin{itemize}[leftmargin=*] + \item the rule identifier $p \in R$; + \item the match identifier for the skeleton step; + \item any attachment-rule identifiers used in the same tick; + \item auxiliary metadata (timestamps, policy hashes, etc.). +\end{itemize} +We abstract this as a finite record in some fixed alphabet; in +particular, we assume it has a self-delimiting encoding. + +For a value $v$ in some state $S_i$ we define a \emph{derivation graph} +$\mathcal{D}(v)$ whose nodes are intermediate values and whose edges are +microstep applications that produced them; the construction is standard +and we omit the routine details. Because we only consider finite derivations +\[ + S_0 \Rewrite^{\mu_0} S_1 \Rewrite^{\mu_1} \cdots + \Rewrite^{\mu_{n-1}} S_n, +\] +every provenance edge in $\mathcal{D}(v)$ points from a value in some +state $S_j$ to a value in a strictly later state $S_{j'}$ with $j' > j$. +Immutability ensures that values are never updated in-place, only created +at later ticks. Hence every causal chain leading to $v$ has length at +most $n$, and $\mathcal{D}(v)$ is a finite, acyclic graph. +Comment on lines +30 to +42 +@coderabbitai +coderabbitai bot +3 hours ago +⚠️ Potential issue | 🟠 Major + +Tighten the finiteness/acyclicity justification for the derivation graph. + +Right now you jump from “finite derivation” + forward‑in‑time edges to “(\mathcal{D}(v)) is a finite, acyclic graph” in one sentence. Acyclicity is fine (edges strictly increase tick index), but finiteness actually uses two separate facts: + +Only finitely many states (S_0,\dots,S_n) occur in the volume. +Each state is a finite RMG state (finite underlying graph), so only finitely many values ever appear. +I’d spell that out and avoid the slightly misleading “Because we only consider finite derivations … every provenance edge …” phrasing. For example: + +-For a value $v$ in some state $S_i$ we define a \emph{derivation graph} +-$\mathcal{D}(v)$ whose nodes are intermediate values and whose edges are +-microstep applications that produced them; the construction is standard +-and we omit the routine details. Because we only consider finite derivations +-\[ +- S_0 \Rewrite^{\mu_0} S_1 \Rewrite^{\mu_1} \cdots +- \Rewrite^{\mu_{n-1}} S_n, +-\] +-every provenance edge in $\mathcal{D}(v)$ points from a value in some +-state $S_j$ to a value in a strictly later state $S_{j'}$ with $j' > j$. +-Immutability ensures that values are never updated in-place, only created +-at later ticks. Hence every causal chain leading to $v$ has length at +-most $n$, and $\mathcal{D}(v)$ is a finite, acyclic graph. ++For a value $v$ in some state $S_i$ we define a \emph{derivation graph} ++$\mathcal{D}(v)$ whose nodes are intermediate values and whose edges are ++microstep applications that produced them; the construction is standard ++and we omit the routine details. For a finite derivation ++\[ ++ S_0 \Rewrite^{\mu_0} S_1 \Rewrite^{\mu_1} \cdots ++ \Rewrite^{\mu_{n-1}} S_n, ++\] ++each microstep consumes values in some $S_j$ and produces new values in ++the strictly later state $S_{j+1}$, so every provenance edge in ++$\mathcal{D}(v)$ points from a value in $S_j$ to a value in $S_{j'}$ ++with $j' > j$. Immutability ensures that values are never updated ++in-place, only created at later ticks. Since each RMG state $S_j$ is ++finite and there are only $n+1$ such states along the derivation, ++$\mathcal{D}(v)$ has finitely many nodes; and because tick indices ++strictly increase along edges, every causal chain leading to $v$ has ++length at most $n$, so $\mathcal{D}(v)$ is a finite acyclic graph. + +--- + +Comment on lines +167 to +176 +@coderabbitai +coderabbitai bot +3 hours ago +⚠️ Potential issue | 🟠 Major + +Stop crediting tick‑level confluence for what is really determinism in the reconstruction definition. + +You fixed the determinism vs confluence split in the wormhole definition, but here you still say: + +“By Theorem~\textbackslash ref{thm:tick-confluence}, each (S_{i+1}) is well-defined up to isomorphism.” + +However, the fact that (\Apply(S_i,\mu_i)) yields a unique successor is fundamentally determinism of the tick semantics; tick‑level confluence is about independence of interleavings of concurrent matches. + +I’d mirror the earlier wording and make both roles explicit: + +- S_{i+1} \;=\; \Apply(S_i,\mu_i) +-\] +-for $0 \le i < n$, where $\Apply$ executes the unique microstep +-described by~$\mu_i$ under the tick semantics. By +-Theorem~\ref{thm:tick-confluence}, each $S_{i+1}$ is well-defined up +-to isomorphism. ++ S_{i+1} \;=\; \Apply(S_i,\mu_i) ++\] ++for $0 \le i < n$, where $\Apply$ executes the unique microstep ++described by~$\mu_i$ under the deterministic tick semantics. ++Determinism ensures that each $S_{i+1}$ is uniquely determined (up to ++isomorphism), while tick-level confluence ++(Theorem~\ref{thm:tick-confluence}) guarantees that any internal ++interleaving of concurrent matches compatible with $\mu_i$ yields an ++isomorphic successor. +Otherwise you’re (again) implicitly loading determinism into a theorem that’s nominally about confluence. + +--- + +aion-holography/sections/multiway_ruliad.tex lines 89 and 98-100: the +punctuation for the time model triad is inconsistent ("Chronos--Kairos--Aion" vs +"Chronos, Kairos, Aion"); choose one convention and make all occurrences +identical—either replace the commas with en-dashes on lines 98-100 +(Chronos--Kairos--Aion) if treating it as a compound triad, or replace the +en-dashes on line 89 with commas on line 89 (Chronos, Kairos, Aion) if treating +them as a simple list—then update every other instance in the file to match. + +--- + +Comment on lines +59 to +71 +@coderabbitai +coderabbitai bot +3 hours ago +⚠️ Potential issue | 🟠 Major + +RMG morphism definition still lacks a base case and a clear ambient category for atoms. + +You fixed the overt circularity by switching to “structural recursion on RMG depth”, but this is still incomplete: + +You only give a clause for composite objects ((S,\alpha,\beta)); there is no base case describing morphisms between atoms (\mathrm{Atom}(p)). +You say “for each (v) a morphism of attachments (f_v : \alpha(v) \To \alpha'(f_V(v)))”, but you never specify in which category these attachment morphisms live. Previously this was (incorrectly) “in (\RMG)”; now it’s just floating. +As written, (\RMG) is not actually a category: Hom‑sets between atomic objects are undefined, and the recursion on attachments has no base case. + +You need to either: + +Treat the payloads (P) as a discrete base category (most conservative), or +Parametrise RMGs over an arbitrary small base category (\mathcal{C}) of atomic payloads and make that explicit. +Here’s a concrete minimal patch using the discrete‑payload option: + +-\begin{definition}[RMG morphism] +-We define morphisms by structural recursion on RMG depth. A morphism +-$f : (S,\alpha,\beta) \To (S',\alpha',\beta')$ consists of: ++\begin{definition}[RMG morphism] ++We define morphisms by structural recursion on RMG depth, taking the ++set of atomic payloads $P$ as a discrete category (only identity ++morphisms). Thus ++\[ ++ \Hom(\Atom(p),\Atom(p')) = ++ \begin{cases} ++ \{\id_{\Atom(p)}\} & \text{if } p = p',\\ ++ \emptyset & \text{otherwise.} ++ \end{cases} ++\] ++For composite objects, a morphism ++$f : (S,\alpha,\beta) \To (S',\alpha',\beta')$ consists of: +@@ +- \item for each $v \in V$ a morphism of attachments +- $f_v : \alpha(v) \To \alpha'(f_V(v))$ and, for each $e \in E$, a +- morphism $f_e : \beta(e) \To \beta'(f_E(e))$, defined recursively +- using the same clause whenever an attachment is itself of the form +- $(S,\alpha,\beta)$. ++ \item for each $v \in V$ a morphism of attachments ++ $f_v : \alpha(v) \To \alpha'(f_V(v))$ and, for each $e \in E$, a ++ morphism $f_e : \beta(e) \To \beta'(f_E(e))$, where each $f_v$ and ++ $f_e$ is itself an RMG morphism, defined recursively on the depth ++ of the attachment. +If you need nontrivial maps between atoms later, just replace “discrete category on (P)” with “small base category (\mathcal{C}) whose objects are payloads” and adjust the Hom‑clause accordingly. But as it stands, the category structure you claim for (\RMG) is underspecified. + +🤖 Prompt for AI Agents +In aion-holography/sections/rmg.tex around lines 59–71, the RMG morphism +definition omits a base case for atoms and fails to specify the ambient category +for attachment morphisms; add an explicit base clause that defines Hom(Atom(p), +Atom(q)) (e.g. make payloads P a discrete category so Hom(Atom(p),Atom(q)) = +empty unless p=q, where it is the identity), and state that every attachment +morphism f_v and f_e lives in that chosen base category (or alternatively +parameterize the whole definition over a small base category C of payloads and +replace “in RMG” with morphisms in C); update the recursive clause to stop at +atoms using that base-case Hom and ensure composition/identities use the +base-category identities for atomic attachments. + +--- + + +Original file line number Diff line number Diff line change +@@ -0,0 +1,162 @@ +\sectionbreak +\section{Recursive Metagraphs} +\label{sec:rmg} + +In this section we define Recursive Metagraphs (RMGs) and relate them to +standard graph models and typed open graphs. An RMG is a finite typed +open graph whose nodes and edges may themselves carry RMGs recursively, +forming a finitely branching, well-founded tree of graphs. + +\subsection{Inductive definition} + +Fix a set $P$ of atomic payloads (blobs, literals, external IDs). + +\begin{definition}[Recursive Metagraph]\label{def:rmg} +The class $\RMG$ of \emph{recursive metagraphs} is the least set closed +under the following constructors: +\begin{enumerate}[leftmargin=*] + \item for each $p \in P$ there is an \emph{atom} $\mathrm{Atom}(p) + \in \RMG$; + \item for any finite directed multigraph $S = (V,E,s,t)$ and + assignments $\alpha : V \To \RMG$, $\beta : E \To \RMG$, the triple + $(S,\alpha,\beta)$ is in $\RMG$. +\end{enumerate} +\end{definition} + +We write an element of $\RMG$ as either an atom or as a ``1-skeleton'' +graph decorated by attachments on vertices and edges. Attachments +themselves may be recursive metagraphs, so this attachment structure +can nest arbitrarily deeply. This definition agrees with the +set-theoretic and initial-algebra presentation developed in previous +technical notes. + +\paragraph{Example (A tiny recursive metagraph).} +As a concrete instance, consider a program call graph where each +function node carries its own abstract syntax tree (AST) and each call +edge carries a small provenance graph (e.g.\ optimisation decisions or +runtime statistics). We can model this as an RMG whose skeleton has +nodes $v_f,v_g$ for functions $f,g$, a directed edge +$e_{\mathsf{call}} : v_f \to v_g$ for the call, and attachments: +$\alpha(v_f)$ the AST of $f$, $\alpha(v_g)$ the AST of $g$, and +$\beta(e_{\mathsf{call}})$ the call provenance. + +\subsection{Initial algebra viewpoint} + +Let $\mathcal{G}$ be a small collection of allowable skeleton shapes +(finite directed multigraphs up to isomorphism). Define a finitary +polynomial endofunctor +$F : \Set \To \Set$ by +\[ + F(X) = P + \coprod_{S\in\mathcal{G}} (V_S \To X) \times (E_S \To X). +\] +Then $\RMG$ is (up to isomorphism) the carrier of the initial +$F$-algebra. This yields the usual structural recursion and induction +principles: every function out of $\RMG$ is uniquely determined by its +action on atoms and on decorated skeletons. + +\subsection{Morphisms and category of RMGs} + +\begin{definition}[RMG morphism] +We define morphisms by structural recursion on RMG depth. A morphism +$f : (S,\alpha,\beta) \To (S',\alpha',\beta')$ consists of: +\begin{itemize}[leftmargin=*] + \item a graph homomorphism of skeletons $f_V : V \To V'$, $f_E : E \To + E'$ preserving sources and targets; and + \item for each $v \in V$ a morphism of attachments + $f_v : \alpha(v) \To \alpha'(f_V(v))$ and, for each $e \in E$, a + morphism $f_e : \beta(e) \To \beta'(f_E(e))$, defined recursively + using the same clause whenever an attachment is itself of the form + $(S,\alpha,\beta)$. +\end{itemize} +Composition and identities are defined componentwise. +flyingrobots marked this conversation as resolved. +\end{definition} +\begin{figure}[t] + \centering + \begin{tikzpicture}[ + snode/.style={circle,draw=purple!70!black,fill=purple!10,thick,minimum size=10mm,inner sep=0pt}, + sedge/.style={-Latex,thick,purple!70!black}, + anode/.style={circle,draw=orange!70!black,fill=orange!8,thin,minimum size=4mm,inner sep=0pt}, + aedge/.style={-Latex,thin,orange!70!black}, + >=Latex + ] + + % Skeleton level + \node[snode] (v1) at (0,0) {$v_1$}; + \node[snode] (v2) at (3.0,0) {$v_2$}; + \draw[sedge] (v1) -- node[above]{\small $e_{\mathsf{call}}$} (v2); + + \node at (1.5,-1.0) {\small skeleton $G$}; + + % Attachment for v1 (e.g. an AST) + \begin{scope}[shift={(-2.4,1.6)}] + \node[anode] (a1) at (0,0) {}; + \node[anode] (a2) at (0.9,0.6) {}; + \node[anode] (a3) at (0.9,-0.6) {}; + \draw[aedge] (a1) -- (a2); + \draw[aedge] (a1) -- (a3); + \node[anchor=east] at (-0.1,0) {\small $\alpha(v_1)$}; + \end{scope} + \draw[thin,dashed] (-0.3,0.5) to[out=150,in=0] (-1.5,1.6); + + % Attachment for v2 + \begin{scope}[shift={(1.8,1.6)}] + \node[anode] (b1) at (0,0) {}; + \node[anode] (b2) at (0.9,0) {}; + \node[anode] (b3) at (0.45,0.8) {}; + \draw[aedge] (b1) -- (b2); + \draw[aedge] (b2) -- (b3); + \draw[aedge] (b3) -- (b1); + \node[anchor=east] at (-0.1,0) {\small $\alpha(v_2)$}; + \end{scope} + \draw[thin,dashed] (3.3,0.5) to[out=30,in=180] (2.7,1.6); + + % Attachment for edge e + \begin{scope}[shift={(1.5,-2.0)}] + \node[anode] (c1) at (-0.6,0) {}; + \node[anode] (c2) at (0.6,0) {}; + \draw[aedge] (c1) -- (c2); + \node at (0,-0.8) {\small $\beta(e_{\mathsf{call}})$}; + \end{scope} + \draw[thin,dashed] (1.5,-0.2) -- (1.5,-1.4); + + \end{tikzpicture} + \caption{A simple recursive metagraph: the skeleton $G$ has two + nodes $v_1,v_2$ and an edge $e_{\mathsf{call}}$, while each node and + edge carries its own attached graph $\alpha(v_i),\beta(e_{\mathsf{call}})$. + In an RMG this attachment structure recurses: the attachment graphs + themselves may have attachments, and so on.} + \label{fig:rmg-recursive-example} +\end{figure} + +\subsection{Relation to ordinary and hypergraphs} + +Typed open graphs $\OGraph_T$ form an adhesive category, and DPO +rewriting is well-behaved there. Typed hypergraphs embed fully and +faithfully into typed open graphs via an incidence construction that +preserves DPO steps and their multiway derivations. +Thus RMG rewriting subsumes standard open-graph and hypergraph +rewriting while adding recursive structure through attachments. + +\subsection{Notation summary} + +For convenience, we collect the main notation introduced so far: + +\medskip +\begin{center} +\begin{tabular}{ll} +\textbf{Symbol} & \textbf{Meaning} \\[2pt] +\hline\\[-8pt] +$\mathcal{U} = (G;\alpha,\beta)$ & single RMG state (one object in a universe $\mathcal{U}$) \\ +$p = (L \xleftarrow{\ell} K \xrightarrow{r} R)$ & DPOI rule \\ +$\mu_i$ & microstep label \\ +$P = (\mu_0,\dots,\mu_{n-1})$ & provenance payload \\ +$S_0 \Rewrite^\ast S_n$ & derivation volume (interior evolution) \\ +$(S_0,P)$ & wormhole (boundary encoding) \\ +$\Del(m), \Use(m)$ & delete and use sets of a match \\ +$\Recon(S_0,P)$ & reconstruction procedure \\ +\end{tabular} +\end{center} +\medskip + +Subsequent sections introduce $D_{\tau,m}$ (rulial distance), +Comment on lines +149 to +161 +@coderabbitai +coderabbitai bot +3 hours ago +⚠️ Potential issue | 🟠 Major + +Notation for (\mathcal{U}) vs (U) is now self‑contradictory; fix the universe symbol. + +The table entry currently reads: + +$\mathcal{U} = (G;\alpha,\beta)$ & single RMG state (one object in a universe $\mathcal{U}$) \\ +You’re using (\mathcal{U}) simultaneously for: + +A single RMG state, and +The ambient “universe” containing that state. +Then, two lines later, you introduce (\Hist(U,R)), where (U) is clearly meant to be the collection/category of RMG states. This is exactly the ambiguity the earlier review asked you to avoid, and the new wording makes it worse. + +I’d disambiguate as follows: + +-$\mathcal{U} = (G;\alpha,\beta)$ & single RMG state (one object in a universe $\mathcal{U}$) \\ ++$\mathcal{U} = (G;\alpha,\beta)$ & single RMG state (one object in an RMG universe $U$) \\ +@@ +-Subsequent sections introduce $D_{\tau,m}$ (rulial distance), +-$\Hist(U,R)$ (history category), and other observer-related notation. ++Subsequent sections introduce $D_{\tau,m}$ (rulial distance), ++$\Hist(U,R)$ (history category on a universe $U$ of RMG states), and ++other observer-related notation. +That way (\mathcal{U}) is consistently “a particular state” and (U) is “the collection/category of such states”. + +🤖 Prompt for AI Agents +In aion-holography/sections/rmg.tex around lines 149-161, the symbol \mathcal{U} +is used inconsistently as both a single RMG state and the ambient universe; +change the notation so \mathcal{U} denotes one particular RMG state (e.g. +“\mathcal{U} = (G;\alpha,\beta)” and describe it as “a single RMG state”), +reserve U (plain U) for the collection/category of states (the universe), update +the table entry text accordingly, and then search and replace other occurrences +in this section (e.g. \Hist(U,R) and any sentences that refer to “universe”) to +use U when referring to the collection and \mathcal{U} when referring to an +individual state so the notation is consistent throughout. + +-- + +Review is correct but critically incomplete—fixes needed at three locations, not one. + +The bibliography indeed mixes formats. However, your diff only addresses line 2 (Ehrig2006). The regex verification found THREE entries using "First Last" format: + +Line 2 (Ehrig2006): needs fix ✓ (covered by your diff) +Line 9: author = {Hartmut Ehrig and Michael L{\"o}we} — needs fix +Line 30: author = {Bob Coecke and Ross Duncan} — needs fix +Lines 73, 84 (LS06, EEPT06) are already correctly formatted as "Last, First" and require no changes. + +Apply the diff to line 2, then standardize lines 9 and 30 to Last, FirstName format as well. Verify the entire file has zero remaining "First Last" entries after the fixes.