chronomancy.io

History

Coleman Dimensional Encoding is the result of asking myself one question:

Why are computers still so slow in 2026?

I've been programming since I was six, starting with BASIC and 6502 assembly. Decades later I'm playing XCOM 2, and the AI takes longer to decide its turn than it takes ZORK to load on my Commodore 64. What was the loading screen for if every turn computes everything from scratch? Cover, elevation, sight lines, and threat levels are all known, all structured, and all recomputed for every unit, for every turn. My rig is generating waste heat from the same questions it has asked over and over before, funneling electrons into the same answers out of an assumption: this is the way it is, and computers are just slow at these sorts of problems. But the machine isn't slow; the work is redundant. The structure was never designed to answer the questions being asked of it, and not only can we fix that, we can codify that structure using dimensional thinking.

The idea that dimensions hide things in plain sight has been with me as long as I can remember. I grew up watching Quantum Leap as a little kid every evening, Sam Beckett leaping through time, striving to put right what once went wrong (cue the theme music). The premise was that time is not a wall but a corridor, something you can actually move through and aren't bound by. It's a dimension, and dimensions are things you can navigate.

Then I read Flatland just a few years later, a story about a square living in two dimensions who can see the sphere passing through his world only as a circle that grows and shrinks, never as the sphere it is. Not because the sphere isn't there, but because the square doesn't have the axis to perceive it. The information exists, but the dimension to see it does not.

Then I read about Kaluza Klein theory, and the intuition became physics. In 1919 Theodor Kaluza took Einstein's field equations for general relativity, which describe gravity as curvature in four dimensional spacetime, and extended them to five dimensions. Einstein hesitated over the paper for two years before presenting it to the Prussian Academy in 1921. Kaluza didn't postulate new forces by hand. He added one more axis to the geometry, plus one simplifying assumption: that nothing varies along it.

When he worked out the math, the electromagnetic potential appeared automatically as components of the five dimensional metric, and Maxwell's equations fell out of the five dimensional field equations. In 1926 Oskar Klein showed how this fifth dimension could be compactified, curled into a circle so small it's unobservable, while its effects remain everywhere. Electromagnetism wasn't a separate force bolted onto gravity. It was curvature in a dimension that had always been there, one that the four dimensional model simply couldn't represent.

Framework

The pattern is always the same: information that looks missing from one perspective is already there, encoded in a dimension that the perspective doesn't include. What if data systems worked the same way? What if you could add the right dimensions to a dataset so that every query followed a geodesic, the shortest possible path through the structure to the answer?

WASPWorkload Aware Sufficient Placement

Defines the problem. Every true answer is found, every false positive is filtered, work scales with the answer rather than the dataset, and no dimension is wasted.

CDEColeman Dimensional Encoding

Solves it. Analyze the workload, encode each record as a coordinate, build the index, translate queries into bounded probes.

MSSMinimally Sufficient Statistics

Keeps it honest. Every claim is classified as a definition, guarantee, assumption, or unknown. Nothing is stated without knowing which category it belongs to.

Formal Definitions

WASP

Let $D$ be a finite set of records and $Q$ a set of queries, where each query is a predicate $q: D \to \{0, 1\}$. Let the workload be $W \subseteq Q$. A WASP instance consists of five components:

  1. $k \ge 1$: number of encoding dimensions
  2. $E: D \to \mathbb{Z}^k$: maps each record to a coordinate
  3. $I: \mathbb{Z}^k \to \mathcal{P}(D)$: maps each coordinate to the records stored there
  4. $T: Q \to \mathcal{P}(\mathbb{Z}^k)$: maps each query to coordinates to probe
  5. $F: Q \times D \to \{0, 1\}$: a per query predicate evaluated on candidates

Index exactness: $\forall c \in \mathbb{Z}^k: I(c) = \{r \in D : E(r) = c\}$.

Five building blocks. $k$ sets how many dimensions the space has. $E$ places each record at a coordinate. $I$ retrieves records from a coordinate. $T$ converts a query into coordinates to check. $F_q$ is the filter that will be asked to remove false positives. The index exactness constraint says each coordinate holds exactly the records assigned to it: the index is the encoder run backwards, so probed buckets never overlap and nothing hides anywhere else.

These define three quantities for any query $q$:

$$\mathrm{Ans}(q) = \{r \in D : q(r) = 1\}$$ $$\mathrm{Cand}(q) = \bigcup_{c \in T(q)} I(c)$$ $$\mathrm{Work}(q) = |T(q)| + |\mathrm{Cand}(q)|$$

$\mathrm{Ans}(q)$ is the perfect answer, every record that truly matches. $\mathrm{Cand}(q)$ is what the index returns; it may include extras. $\mathrm{Work}(q)$ is the total cost, coordinates probed plus records examined; because index exactness keeps buckets disjoint, $|\mathrm{Cand}(q)|$ counts every record actually touched, with no undercounting from overlap. Evaluating $F_q(r)$ is assumed O(1) per candidate.

A valid solution satisfies four properties:

Sufficiency

$$\forall q \in W: \mathrm{Ans}(q) \subseteq \mathrm{Cand}(q)$$

Equivalently, by index exactness: $\forall q \in W, \forall r \in D: q(r) = 1 \Rightarrow E(r) \in T(q)$. Without index exactness only the reverse direction would hold; with it, the equivalence is a theorem.

Exactness

$$\forall q \in W, \forall r \in \mathrm{Cand}(q): F_q(r) = q(r)$$

Theorem (from Sufficiency + Exactness): $\forall q \in W: \mathrm{Ans}(q) = \{r \in \mathrm{Cand}(q) : F_q(r) = 1\}$.

Bounded work: the scheme declares constants $\gamma, \beta \ge 0$ up front, independent of $|D|$, and they must hold for every dataset the scheme admits, not just one snapshot:

$$\forall q \in W: \mathrm{Work}(q) \le \gamma\,|\mathrm{Ans}(q)| + \beta$$

Constants chosen after seeing the data could absorb a full scan; declared constants cannot.

Minimality: removing dimension $i$ means projecting through $\pi_{-i}: \mathbb{Z}^k \to \mathbb{Z}^{k-1}$ (delete coordinate $i$), which induces $E' = \pi_{-i} \circ E$, $I'(c') = \{r \in D : E'(r) = c'\}$, and $T'(q) = \{\pi_{-i}(c) : c \in T(q)\}$, with $F$ unchanged. Sufficiency survives every such projection (a theorem, not an accident), so Minimality holds when $\forall i \in \{1, \ldots, k\}$: the projected scheme violates Exactness or Bounded work, with the same declared $\gamma, \beta$, on $W$.

You never miss a correct answer. The filter agrees with the query on every candidate. Effort grows with the answer size, not the dataset size, and the constants are pinned before the data arrives; otherwise a full scan would qualify. Every dimension earns its keep: drop one, collapse the space one axis, and the filter or the declared work bound must break. The one thing a projection can never break is Sufficiency; that direction is proved once, for every scheme.

CDE

Given a workload $W$, construct the five WASP components in four phases:

  1. Workload analysis: derive candidate dimensions from $W$
  2. Coordinate encoding: define discretizers per dimension, compute $E(r)$
  3. Index construction: build $I(c)$ from observed coordinates
  4. Query translation: implement $T(q)$ and $F_q$, then verify all four properties on the assembled instance; a failure sends you back to an earlier phase

Study the questions to discover natural axes. Assign each record a position on those axes. Build the lookup from positions to records. Convert incoming queries into bounded coordinate scans, then check the whole construction: phase four can witness the properties, but only the earlier phases can create them.

MSS

Given a statement set $S$ and an inference relation $\vdash$ (ordinary logical consequence over the document's stated semantics), define a labeling function $L: S \to \{\text{Def}, \text{Gua}, \text{Asm}, \text{Unk}\}$ such that:

  1. Soundness: Def is reserved for stipulations, statements made true by choice; every claim about observed or promised behavior is labeled Gua, Asm, or Unk
  2. Traceability: every Guarantee carries a derivation from Definitions and Assumptions alone
  3. Independence: no Assumption is derivable from the other Assumptions and Definitions
  4. No laundering: no derivation presented anywhere in the description cites an Unknown as a premise

A description is minimally sufficient when $L$ satisfies all four criteria: sufficient because every Guarantee carries its support, minimal because no Assumption is redundant.

Every statement gets exactly one label. Definitions are choices; they cannot be wrong, only changed, and nothing empirical may hide among them. Guarantees are earned from Definitions and Assumptions. Assumptions are bets; if one is wrong, every Guarantee leaning on it falls. Unknowns are honest gaps, and nothing downstream may quietly stand on them.

Repositories

Working implementations. Each one applies the same dimensional thinking to a different constraint.

chronoforth Minimal Forth for the Commodore 64, built on DurexForth. The kernel and default disk stay lean, with graphics, sound, and float available as optional Forth modules when you want them. It is subroutine threaded with tail call elimination, and one hot primitive is open coded: DROP compiles to a single 2 cycle INX instead of a 14 cycle call. Every documented cycle count is measured with chrono6502, never estimated.
chronosat A 3SAT verifier in Forth for a stock Commodore 64, three literals per clause, with every recorded run reproducible in the VICE emulator. Each clause packs into six bytes with bit 15 marking negation, about 680:1 against a dense matrix of 16 bit coefficients. It checks 2048 variables across 1024 clauses in a measured 6.3 seconds at 1 MHz, about 160 clause checks a second, and a cycle analysis puts the compute floor near 123K cycles: roughly 50x of headroom waiting for a future native 6502 kernel.
chrono6502 A headless, cycle exact MOS 6502 core in Rust with zero dependencies, covering the complete documented instruction set. It boots the real ChronoForth kernel in process, runs every Forth 2012 test ChronoForth ships (core, core plus, core extension, exception) in about 0.45 seconds, and reports the exact cycle cost of any computational word. It is the instrument that turned the other C64 repos' estimates into measurements.
chronosynthea A synthetic patient generator in Rust. It samples a precomputed statistical fingerprint instead of stepping a state machine for every patient, with a bundled registry carrying calibration to Java Synthea's marginal prevalence rates inherited from an earlier Go implementation. Archetype choice is one O(1) alias table draw. Condition sampling is SIMD threshold comparisons on every generation path, verified bit identical to the scalar baseline on the shipped registry. Millions of patients a second on the stats path, tens of thousands a second writing full records as JSONL or MessagePack. It trades Java's step by step causal simulation for speed, reproducing the fingerprint's condition rates to within sampling noise.
chronohipaa A Python reference encoder that maps each health record to a fixed 20 byte (154 bit) vector across six dimensions: temporal, demographic, clinical, geographic, treatment, status. Compact and lossy on purpose. The clinical and treatment dimensions are salted SHA256 fingerprints truncated to 32 bits, built for fast grouping and linkage rather than cryptographic hiding, and the temporal field is encrypted (AES GCM under an HKDF derived key with a per record nonce). A research encoder and reference design; certified deidentification remains its own project.
chronoscribe A seven stage Python pipeline that turns Internet Archive hOCR scans into clean Markdown. CDE makes each token correction decision a deterministic O(1) lookup in a 96 entry decision table over five quantized dimensions. Every stage is linear in the token count, and the 322 page test book cleans in about 4 seconds, roughly 81 pages a second, with output verified byte for byte across the speedup. Ground truth accuracy measurement is the next milestone.
chronocom A combat and tactical AI overhaul for XCOM 2: War of the Chosen, in UnrealScript. The displayed hit chance and the roll share one transparent formula, and a unified roll class stands ready to retire the last of the vanilla aim assist. It tracks player tactics across the campaign, with the counter tactics hook staged for the AI's decision loop. A fixed 32 by 32 influence grid plus fixed capacity caches turn spatial queries into bounded probes that stay fixed cost as the map fills up. The guarantees are structural by design; benchmarks are on the roadmap.
chronoquit A macOS menu bar utility that encodes each running app as a seven dimensional state vector (activity, system impact, protection, interaction, priority, lifecycle, user preference) and runs a small lifecycle state machine. It quits idle, low priority apps once they cross a threshold, rather than on a blanket timer.
chronoboiler Zero dependency bash scaffolding with per language YAML configs and shared templates. It gives the chronomancy repositories one consistent structure and checks them against that standard. The four CDE dimensions here serve as the scripts' descriptive taxonomy.

Coda

The symbol at the top of this page is the nabla, ∇. It is the gradient operator. Applied to a scalar field, it returns a vector pointing in the direction of steepest ascent. Applied to a dataset with the right dimensions, it does the same thing; the shortest path to the answer reveals itself.

The shape of the symbol is not incidental. A T shaped person has one deep vertical specialty and a horizontal bar of broad but shallow knowledge. The nabla is the next step. It is the shape of a polyglot, a converging geometry where many domains, languages, and perspectives flow inward and focus into a single, decisive direction of movement.

This is the Coleman Dimensional Encoding framework.

Not faster hardware. Not cleverer algorithms acting on the same flat structures. Just the precise dimensions, derived from the questions themselves, encoded directly into the geometry of the data.

When the dimensions are right, the gradient does not need to be forced. The steepest path simply reveals itself. This happens not because the answer was hidden, but because the shape of the question finally possessed the capacity to find it.