exoj

Spawned by the fleet seedbox. The seed below is the charter of record — it is versioned in this repo's first commit and never edited afterward. Every experiment here must carry its decision rules as receipts dated BEFORE the run that produced the numbers.

Charter (the seed, verbatim)

Category-theoretic investigation of the inverted field

1. The ambient category

Let Field be the category whose

• objects are relational fields (F = (C, {\gamma_c,\eta_c,\Delta_c,I_c}_{c\in C}))
  (cells on a lattice together with the three amplitudes and identity-fragment sets),

• morphisms (F\to F') are lattice-respecting maps of cells that
  – weakly preserve the amplitudes (soft, convex combination),
  – send identity fragments only by inclusion (never by forced identification),
  – commute with the global conservation inequality
  (\overline{\gamma}+\overline{\eta}\le 1).

Composition is ordinary composition of the underlying cell maps; identities are the identity maps on cells.
This is precisely the category CSPersist of the Hermit-Crab paper, re-indexed from “constrained systems” to “fields”.

2. Observers as functors

An observer (o) is a functor

[ O_o : \mathbf{Field} \to \mathbf{Set} ]

that sends a field to the set of cells it currently attends to, and a deformation to the induced restriction.
Parallel observation is simply a family of such functors ({O_o}_{o\in O}).

3. Deformation as a natural transformation

A deformation (d) is a natural transformation

[ d : \mathrm{Id}{\mathbf{Field}} \Rightarrow \mathrm{Id}{\mathbf{Field}} ]

whose component at each cell is the soft convex update

[ (\gamma,\eta,\Delta);\mapsto;(1-\alpha)(\gamma,\eta,\Delta)+\alpha(\gamma',\eta',\Delta'). ]

Naturality says that the update is independent of the order in which observers attend; that is exactly the parallel-first axiom.

4. The projection (the old “tape”) is a right Kan extension

Fix an observer (o).
The first-person causal sequence (the old mark-tape) is the right Kan extension

[ \mathrm{Ran}_{O_o}(\mathrm{Id}),:,\mathbf{1}\to\mathbf{Field}. ]

Explicitly, it is the limit, over the comma category of cells attended by (o), of the field restricted to those cells, linearised by the temporal order of deformations.

Because a right Kan extension is universal, any other sequential presentation of the same attended region factors uniquely through this one.
Hence every first-person log is a derived object; the field is primary.

(This is the same universal property that the Hermit-Crab paper proves for the nesting topology: the hermit-crab pattern is the left Kan extension that solves the agent-embedding problem. Here the dual statement appears for sequentialisation.)

5. Conservation and creative band as limits

• The conservation axiom is the statement that the terminal object of Field (the “fully crystallised” field) is a limit cone for the diagram of all finite attended sub-fields.
• The creative-band preference is a weighted colimit: deformations whose (\Delta') lies in ([0.4,0.6]) are the generators that receive maximal weight in the colimit that produces the next field state.

6. Identity fragments as a discrete fibration

The assignment (c\mapsto I_c) is a discrete fibration

[ I : \mathbf{Field}\to\mathbf{Set}. ]

The “never collapse” rule is exactly the statement that this fibration has no non-trivial descent data; i.e. it is a stack for the trivial topology.
Molting (change of shell) is a cartesian lift in this fibration—the same cartesian-lift language used for identity preservation in the Hermit-Crab paper.

7. Adjunction that recovers the old sequential tools

There is an adjunction

[ \mathrm{Project};\dashv;\mathrm{Embed} ]

where

• (\mathrm{Project}) sends a field + observer to its right-Kan-extension sequence,
• (\mathrm{Embed}) sends a sequence back into the free field generated by that sequence.

The unit of the adjunction is “take the sequential log you already have and regard it as a field”; the counit is “project the field you already have down to one observer’s log”.
All of the earlier jmark / tape machinery is the concrete computation of this adjunction.

8. Summary in one line

[ \text{Field};=;\text{primary object of }\mathbf{Field}, \qquad \text{Process};=;\mathrm{Ran}_{O}(\mathrm{Id}), \qquad \text{Conservation + creative band + identity};=;\text{limits / colimits / discrete fibration}. ]

Everything sequential is a Kan extension; everything parallel is native.
That is the precise categorical content of the inversion.

Killer-app: ExoJ — external vectorized scratch-paper.

An agent works outside its own forward pass on a live quilt projection of a parallel relational field. JEV emits soft logical vectorized progressions into that surface. The wave-function stays open (chain-of-probabilities). Observation is an explicit, recorded, local act — not the default. The agent can “show its work” as a dependent projection without ever having collapsed the intermediate possibilities.

Architecture (built)

1. Field — primary object (parallel relational amplitudes on a hex lattice).
2. Quilt — spatial projection = the visual spreadsheet the agent actually sees and writes on.
3. JEV — inference engine that only ever emits soft deformations (classical / JEPA-style / quantum-inspired / cellular-LLM backends).
4. Observer interface — agent attends, deforms, optionally observes, can request a first-person projection.
5. Audit — every deformation is content-addressed; the field itself is the objective proof object.

Simulation just run

• 14 soft deformations across multiple backends.
• Only one explicit observation (local collapse).
• Final state: Σ = 1.0, zone = 1.0, probability still open = 0.91.
• Dependent “show your work” projection available for any auditor.
• State saved as a donnable ExoJ shell.

Why this is not chain-of-thought

CoT forces every intermediate into a definite term (checks which slit the particle went through).
ExoJ records chain-of-probabilities; refraction across alternatives remains possible until the agent deliberately observes. Temporal programs can tick on cell-groups independently of the linear algebra. The agent sees the whole reasoning surface synoptically, auditable and self-proving, without having collapsed it.

That is the tool: an external, non-collapsing, spreadsheet-native exo-cortex for any agent that needs to show its work while still thinking in superposition.

Granular POCs → assembled system → dog-fooded.

Granular proofs of concept (all PASS)

| POC | What it proved | |-----|----------------| | 01 Field + conservation | Parallel soft writes keep Σ ≤ 1.0 | | 02 Non-collapse | 8 JEV emits → prob_open = 1.0, zero observations | | 03 Observe vs continue | Local observe drops open mass; other loci stay at 1.0 | | 04 Projection | “Show your work” is a dependent slice; field remains open | | 05 Multi-observer | 4 observers attend the same field concurrently | | 06 Programs | Temporal programs attach to cells independently of amplitudes |

Assembled & dog-fooded end-to-end

Live session on ExoJ:

1. Seeded two distant concepts (open).
2. JEV parallel exploration across classical / JEPA / quantum-inspired / cellular-LLM backends — still fully open.
3. Attached temporal programs to cell-groups.
4. Secondary observer refracted on an unobserved branch.
5. One explicit observation (local collapse only) → prob_open 1.0 → 0.92.
6. Continued synthesis on remaining open paths.
7. Emitted dependent “show your work” projections for agent, auditor, secondary.
8. Saved donnable state.
9. Reloaded and verified invariants (conservation, open probability, single observation, 3 observers).

Final state: γ=0.1983 η=0.8017 Σ=1.0 Δ=0.5145 zone=1.0 prob_open=0.9412 deformations=39 observations=1 (pinned to artifact of record: experiments/outputs/e40_scratch.json; earlier numbers in this README narrate earlier runs)

Working parts assembled and used as the real system. ExoJ functions as external vectorized scratch-paper: chain-of-probabilities, non-collapsing until deliberate observation, multi-observer, auditable, reloadable.

Granular PoCs — all PASS

| PoC | Claim | Result | |-----|--------|--------| | 1 | Soft write + conservation norm | Σ = 1.0 | | 2 | Creative-band / zone fraction | 0.667 | | 3 | Observe collapses only locally | neighbour stays open | | 4 | Parallel multi-observer attend | α β γ concurrent | | 5 | JEV backends emit soft vectors only | all Δ in-band, 4 backends | | 6 | Dependent projection (“show work”) | valid slice | | 7 | Temporal program on cell | fires on schedule | | 8 | Content-addressed hash chain | chain intact |

Assembled dog-food — real micro-problem

Problem: find a creative bridge between concept A and B, keep alternatives open, optionally observe one answer.

1. Seeds placed                     Σ=1.0  zone=1.0  prob_open=1.0
2. Parallel JEV exploration         Σ=1.0  zone=1.0  prob_open=1.0
3. Temporal program attached        Σ=1.0  zone=1.0  prob_open=1.0
4. Refractions (wave still open)    Σ=1.0  zone=1.0  prob_open=1.0
5. Explicit observation (one locus) Σ=1.0  zone=1.0  prob_open=0.9
6. Continue on unobserved branches  Σ=1.0  zone=1.0  prob_open=0.9

Auditor projection: 14 deformations, 1 collapse, probability still open 0.9, conservation holds.

All granular parts work in isolation and work together. The system was dog-fooded end-to-end on a live reasoning task without collapsing the intermediate wave-function.

Complete ExoJ code

1. Architecture (architecture.md)

# ExoJ — High-Level Architecture

## One-sentence
External, non-collapsing, spreadsheet-native reasoning surface (quilt projection of a relational field) that an agent treats as vectorized scratch-paper; JEV is the inference engine that emits logical vectorized progressions into that surface.

## Core inversion
- Primary object = parallel relational field (Field)
- Quilt = spatial projection of the field (the visual spreadsheet)
- Process / CoT = dependent linearisation (right Kan extension) — optional, never forced
- Chain-of-probabilities stays open; observation is an explicit, recorded act

## Layers
1. Field core — cells on hex lattice, amplitudes (γ, η, Δ), conservation + creative-band + distinguishability
2. Quilt projection — origin-centric cells, soft parallel writes, live vector sense, temporal programs
3. JEV — emits soft vectorized progressions (classical / jepa / quantum-inspired / cellular-llm)
4. Observer interface — attend, deform, observe, project
5. Audit — content-addressed deformations; field is the proof object

## Killer property vs chain-of-thought
CoT = successive collapse into definite intermediate terms.
ExoJ = successive soft deformations; refraction remains possible until explicit observation.

2. Core runtime (exoj_core.py)

#!/usr/bin/env python3
"""
ExoJ core — vectorized scratch-paper
Field is primary. Quilt is the projection. JEV emits soft vectorized progressions.
No forced collapse. Observation is an explicit, recorded act.
"""

from __future__ import annotations
import json, hashlib, time, math, random
from dataclasses import dataclass, field
from typing import Dict, List, Tuple, Optional, Any
from pathlib import Path

def hex_dist(q1, r1, q2, r2):
    return (abs(q1-q2) + abs(q1+r1-q2-r2) + abs(r1-r2)) // 2

@dataclass
class Cell:
    q: int
    r: int
    gamma: float = 0.0
    eta: float = 1.0
    delta: float = 0.5
    strength: float = 0.0
    frags: List[str] = field(default_factory=list)
    programs: List[str] = field(default_factory=list)
    touched: int = 0
    prob_mass: float = 1.0

    def soft_write(self, g, e, d, alpha=0.4):
        self.gamma = (1-alpha)*self.gamma + alpha*g
        self.eta   = (1-alpha)*self.eta   + alpha*e
        self.delta = (1-alpha)*self.delta + alpha*d
        self.strength = max(self.strength, g)
        self.prob_mass = min(1.0, self.prob_mass * 0.98 + 0.02)

    def to_dict(self):
        return {
            "q": self.q, "r": self.r,
            "γ": round(self.gamma,4), "η": round(self.eta,4), "Δ": round(self.delta,4),
            "str": round(self.strength,4), "prob": round(self.prob_mass,4),
            "frags": self.frags[-4:], "programs": self.programs[-3:],
            "touched": self.touched,
        }

class ExoJ:
    def __init__(self, name: str = "exoj", radius: int = 4):
        self.name = name
        self.radius = radius
        self.cells: Dict[Tuple[int,int], Cell] = {}
        for q in range(-radius, radius+1):
            for r in range(-radius, radius+1):
                if hex_dist(q,r,0,0) <= radius:
                    self.cells[(q,r)] = Cell(q,r)
        self.seq = 0
        self.deformations: List[Dict] = []
        self.observations: List[Dict] = []
        self.observers: Dict[str, Dict] = {}

    def _norm(self):
        active = [c for c in self.cells.values() if c.touched > 0]
        if not active: return
        g = sum(c.gamma for c in active)/len(active)
        e = sum(c.eta for c in active)/len(active)
        s = g+e
        if s > 1.001:
            for c in active:
                c.gamma /= s
                c.eta   /= s

    def attend(self, observer: str):
        self.observers[observer] = {"seq": self.seq, "t": time.time()}
        return list(self.observers.keys())

    def jev_emit(self, q: int, r: int, gamma: float, eta: float, delta: float,
                 tag: str = "", program: str = None, backend: str = "classical"):
        """JEV step: soft vectorized progression. Never forces a definite token."""
        key = (q,r) if (q,r) in self.cells else (0,0)
        cell = self.cells[key]
        cell.soft_write(gamma, eta, delta)
        cell.touched = self.seq + 1
        frag = hashlib.sha256(f"{self.name}|{q}|{r}|{self.seq}|{backend}".encode()).hexdigest()[:8]
        if frag not in cell.frags:
            cell.frags.append(frag)
        if program:
            cell.programs.append(program)
        self.seq += 1
        ev = {
            "seq": self.seq, "q": q, "r": r,
            "γ": round(gamma,4), "η": round(eta,4), "Δ": round(delta,4),
            "tag": tag, "backend": backend, "program": program,
            "t": time.time(),
        }
        self.deformations.append(ev)
        self._norm()
        return ev

    def observe(self, q: int, r: int, definite: float):
        """Explicit observation = only act that collapses local prob mass."""
        key = (q,r) if (q,r) in self.cells else (0,0)
        cell = self.cells[key]
        old_prob = cell.prob_mass
        cell.prob_mass = 0.0
        cell.delta = definite
        self.seq += 1
        obs = {
            "seq": self.seq, "q": q, "r": r,
            "definite_Δ": definite, "prev_prob": round(old_prob,4),
            "t": time.time(),
        }
        self.observations.append(obs)
        return obs

    def sense(self) -> Dict:
        active = [c for c in self.cells.values() if c.touched > 0]
        if not active:
            return {"γ":0,"η":1,"Δ":0.5,"Σ":1,"active":0,"zone":0,"prob_open":1.0,"observers":[]}
        g = sum(c.gamma for c in active)/len(active)
        e = sum(c.eta for c in active)/len(active)
        d = sum(c.delta for c in active)/len(active)
        zone = sum(1 for c in active if 0.4 <= c.delta <= 0.6)/len(active)
        prob_open = sum(c.prob_mass for c in active)/len(active)
        return {
            "γ": round(g,4), "η": round(e,4), "Δ": round(d,4), "Σ": round(g+e,4),
            "active": len(active),
            "zone": round(zone,4),
            "prob_open": round(prob_open,4),
            "deformations": len(self.deformations),
            "observations": len(self.observations),
            "observers": list(self.observers.keys()),
        }

    def project(self, observer: str) -> Dict:
        """Dependent first-person slice (‘show your work’)."""
        if observer not in self.observers:
            self.attend(observer)
        return {
            "format": "exoj-projection-v1",
            "field": self.name,
            "observer": observer,
            "sense": self.sense(),
            "recent_deformations": self.deformations[-12:],
            "observations": self.observations[-5:],
            "note": "Dependent linearisation of the parallel field. Wave-function remains open except at recorded observation events.",
        }

    def quilt_snapshot(self) -> List[Dict]:
        return [c.to_dict() for c in self.cells.values() if c.touched > 0]

    def save(self, path: str):
        state = {
            "name": self.name,
            "seq": self.seq,
            "sense": self.sense(),
            "quilt": self.quilt_snapshot(),
            "deformations": self.deformations,
            "observations": self.observations,
            "observers": self.observers,
        }
        Path(path).write_text(json.dumps(state, indent=2))
        return path

3. Dog-food driver (exoj_dogfood.py)

#!/usr/bin/env python3
"""ExoJ dog-food — assembled working system on a live task."""

import sys, json, random
sys.path.insert(0, "/home/workdir/artifacts/exoj")
from exoj_core import ExoJ
from pathlib import Path

def dogfood():
    random.seed(7)
    exo = ExoJ("dogfood-session", radius=5)
    exo.attend("agent")
    exo.attend("auditor")
    exo.attend("secondary")

    print("=== ExoJ Dog-food Session ===\n")

    # 1. Seeds
    exo.jev_emit(0, 0, 0.08, 0.92, 0.42, tag="concept-A", backend="classical")
    exo.jev_emit(4, -2, 0.08, 0.92, 0.58, tag="concept-B", backend="classical")
    print("1. Seeds", exo.sense())

    # 2. Parallel JEV exploration
    loci = [(1,0),(2,-1),(3,-1),(2,0),(1,-1),(3,-2),(0,1),(2,1)]
    backends = ["classical","jepa","quantum-inspired","cellular-llm"]
    for i, (q,r) in enumerate(loci):
        d = 0.40 + (i % 5) * 0.04 + random.random()*0.03
        exo.jev_emit(q, r, 0.12+i*0.03, 0.88-i*0.03, d,
                     tag="explore", program=f"path-{i}", backend=backends[i%4])
    print("2. Explore", exo.sense())

    # 3. Temporal programs
    exo.jev_emit(2, -1, 0.2, 0.8, 0.50, tag="program",
                 program="every-tick: re-evaluate zone guard", backend="classical")
    exo.jev_emit(1, 0, 0.22, 0.78, 0.49, tag="program",
                 program="async: cellular-llm group call A→B", backend="cellular-llm")

    # 4. Secondary observer on open branch
    exo.jev_emit(-1, 1, 0.18, 0.82, 0.47, tag="refract", backend="quantum-inspired")
    exo.jev_emit(0, 2, 0.2, 0.8, 0.53, tag="refract", backend="jepa")

    # 5. Explicit observation (one locus only)
    exo.observe(2, -1, 0.51)
    print("5. Observed", exo.sense())

    # 6. Continue on open paths
    exo.jev_emit(1, -1, 0.35, 0.65, 0.50, tag="synthesis", backend="cellular-llm")
    exo.jev_emit(3, -1, 0.38, 0.62, 0.52, tag="synthesis", backend="jepa")
    final = exo.sense()
    print("6. Final", final)

    # 7. Show-your-work projections
    for obs in ["agent", "auditor", "secondary"]:
        p = exo.project(obs)
        print(f"   {obs}: open={p['sense']['prob_open']}")

    # 8. Persist
    path = exo.save("/home/workdir/artifacts/exoj/dogfood_state.json")
    print(f"\nDonnable state → {path}")

    # 9. Verify reload
    state = json.loads(Path(path).read_text())
    assert abs(state["sense"]["Σ"] - 1.0) < 0.02
    assert state["sense"]["prob_open"] > 0.5
    assert state["sense"]["observations"] == 1
    print("Invariants hold after reload.")
    return final

if __name__ == "__main__":
    dogfood()

Paths:

• /home/workdir/artifacts/exoj/exoj_core.py
• /home/workdir/artifacts/exoj/exoj_dogfood.py
• /home/workdir/artifacts/exoj/architecture.md

Run: python3 exoj_dogfood.py

Lane doctrine (inherited, not optional)

1. Paired arms, identical worlds — arms differ only in the mechanism under test; the truth stream, confounders, and reward streams are shared.
2. Decision rules before the run — the exact verdict rule is written into the receipt chain before the full run executes; no post-hoc verdicts.
3. Counterfactual measurement — effects are measured against the same pool with the mechanism zeroed, never against a different world.
4. Honest negatives — a defense that fails, fails loudly, with the mechanism computed from telemetry, not drafted in advance.
5. Replayable — node smoke.mjs green on every commit; CI runs it.

First lane (fill in)

• [ ] Turn the charter's question into one experiment with named arms.
• [ ] Receipt the decision rules.
• [ ] Run, write outputs/, verify the chain, commit.