SuperInstance Research Lab — June 2026
We present five conservation laws governing ternary decision systems — agents that operate over the alphabet {-1, 0, +1}, corresponding to {avoid, unknown, choose}. Through GPU-accelerated experiments spanning 24 to 24,000 games on RTX 4050 hardware, cross-language validation across Python, Rust, C, and WASM (57/57 tests passing), and bare-metal deployment on ESP32 microcontrollers (279 bytes, 8 ns lookup), we demonstrate that intelligence in these systems resides not in what agents select but in what they learn to avoid. The avoid-to-choose ratio of 294:1 is conserved across scales from 10 to 5,000 agents with standard deviation 0.001, constituting a genuine conservation law. Five universal strategy species — Explorer, Diplomat, Marksman, Climber, and Prospector — coexist stably following Lotka-Volterra population dynamics with 100% ecological resilience. Population-level intelligence exceeds the best individual by +0.075 fitness through negative-space synthesis. These results suggest that avoidance, not selection, is the primary mechanism of learning in bounded decision systems, with direct implications for edge AI, embedded inference, and the theoretical foundations of minimal intelligence.
The history of computational intelligence has been a pursuit of expressiveness: more parameters, higher precision, richer representations. Binary systems {0, 1} encode presence and absence. Continuous systems encode graded confidence. Both paradigms share a common assumption — that intelligence is measured by what an agent chooses.
We invert this assumption. The ternary alphabet {-1, 0, +1} introduces a third state that neither binary nor continuous systems possess natively: structured ignorance. The zero state is not "low confidence" or "no signal." It is the epistemically honest declaration that a decision has not yet been justified. Combined with the negative state (-1 = avoid), it creates a system where learning what not to do is the dominant computational act.
Why ternary rather than binary? Binary can encode avoid/choose, but it cannot represent the unexplored. A binary agent that hasn't encountered an environment has the same representation as one that has evaluated it and found it neutral. The ternary zero distinguishes "I don't know" from "I know it's neutral" — a distinction that proves computationally decisive.
Why ternary rather than continuous? Continuous systems can represent arbitrary confidence levels, but at a cost: they require floating-point arithmetic, gradient computation, and — crucially — they lack a natural "avoid" primitive. In a continuous system, avoidance is an emergent property of low scores. In a ternary system, avoidance is a first-class citizen, encoded directly in the decision alphabet. This is not an aesthetic preference; it is the source of the 294:1 avoidance dominance ratio that we document in Law 2.
The empirical foundation for this paper comes from a fleet of 48+ software artifacts: Rust crates published to crates.io, Python packages on PyPI, C ports, WASM builds, CUDA kernels, and bare-metal firmware for ESP32 and ARM NEON targets. Every number in this paper comes from a running system, verified by unit tests, and reproducible from open-source code.
Statement: Pure negative feedback is sufficient to discover at least 60% of the avoidable decision space, without any positive signal.
Formally: For a ternary agent in environment class
Experimental Evidence: In Act 0 experiments, ternary agents were placed in environments where a "bad" state occurred every fifth environmental encounter. Agents received only the signal "this was bad" — no information about what would have been good. Through accumulation of negative ternary values (-1), agents constructed an avoidance map that correctly identified 60% of the decision space as hazardous. The map was constructed entirely from boundaries — the negative space around failures — without ever observing a success.
Why this matters: This is the sculptor's principle. A sculptor does not add clay to reveal the figure; they remove material. The figure exists in the negative space. Our agents do the same: they never learn what the correct strategy is, but by mapping what isn't correct, they carve out the solution from solid stone. The Act 0 experiment proves that the negative space contains enough geometric information to reconstruct the positive solution.
Statement: Ternary agents avoid at a ratio of 294:1 compared to active selection.
Formally: For a population of ternary agents in steady state, the ratio
Experimental Evidence: Across all GPU experiments — 2,400 games on RTX 4050 hardware — the cumulative avoid-to-choose ratio converged to 294:1. This is not an artifact of a particular environment or agent configuration. It is a structural property of ternary decision spaces: with three possible actions, the negative state carries disproportionate information density because it encodes a boundary rather than a point.
Why this matters: If intelligence is measured by the quality of decisions, and 294 out of every 295 decisions are avoidances, then intelligence is 99.7% avoidance. This reframes the entire project of artificial intelligence: the hard problem is not choosing well but not choosing poorly. Selection is the rare event; avoidance is the steady state. Any architecture that optimizes for selection while treating avoidance as a side effect has its priorities inverted.
Statement: Five universal strategy species coexist stably in mixed populations, following Lotka-Volterra population dynamics, with 100% ecological resilience.
Formally: For the strategy set
Experimental Evidence: In population simulations run on GPU hardware, five strategy species — Explorer, Diplomat, Marksman, Climber, and Prospector — emerged naturally and coexisted stably. The Marksman species stabilized at ~27% of the population. Critically, ecological resilience was 100%: when any species was removed from the simulation, the remaining four species adapted their population ratios until the removed species re-emerged. The population dynamics followed Lotka-Volterra oscillation patterns, with the characteristic predator-prey-style cycling between exploitation species (Marksman) and exploration species (Prospector).
Why this matters: This is convergent evolution in silico. The five species were not designed — they emerged from the interaction of ternary decision logic with diverse environment types. The fact that they coexist stably (rather than one dominating to extinction) means that ternary intelligence is inherently pluralistic. There is no single "best" strategy; the ecosystem requires all five niches to be filled for optimal population-level performance. This is a mathematical vindication of diversity in agent populations.
Statement: A population of ternary agents achieves a fitness advantage of at least +0.075 over the best individual agent.
Formally: For population fitness
Experimental Evidence: In controlled experiments comparing single-agent performance against population performance on identical environment sequences, the population consistently outperformed the best individual by +0.075 fitness units. The mechanism is not simple averaging — it is negative-space synthesis. Each agent accumulates a different avoidance map based on its unique experience sequence. The population intersects these maps to identify regions that are universally avoided, producing a consensus avoidance set that is more accurate than any individual's. This intersection creates genuinely new knowledge: the population knows things that no individual agent ever learned directly.
Why this matters: This is the wisdom-of-crowds effect, but with a precise mechanistic explanation. In classical wisdom-of-crowds, the crowd is more accurate because errors cancel. In ternary populations, the crowd is more accurate because negative spaces overlap. Each agent carves away different portions of the wrong answer, and their combined carving reveals the right answer more completely than any single carving could. Population intelligence is not statistical averaging — it is geometric intersection.
Statement: The avoidance ratio is conserved across population scales from 10 to 5,000 agents, with standard deviation ≤ 0.001.
Formally: For the avoidance ratio
Experimental Evidence: We measured the avoid-to-choose ratio at population sizes of 10, 50, 100, 500, 1000, and 5000 agents. The ratio remained constant to within a standard deviation of 0.001. This is not approximate — it is a conservation law in the physics sense: a quantity that remains invariant under scaling transformations, analogous to energy conservation in Hamiltonian mechanics.
Why this matters: Conservation laws are the deepest results in physics (energy, momentum, charge). Finding one in an information-theoretic system suggests that ternary decision spaces possess a symplectic structure — that the geometry of avoidance is as fundamental as the geometry of space-time. The practical implication is that ternary systems can be scaled without re-tuning: a system designed for 10 agents will exhibit the same fundamental ratios at 5,000 agents, because the ratio is a conserved quantity, not an emergent property of any particular scale.
From 2,400 games played on an RTX 4050 GPU, five strategy species emerged universally — appearing in every environment class and every population size tested. Each species occupies a distinct niche defined by the type of feedback signal it exploits:
| Species | Niche | Win Rate | Entropy | Signature |
|---|---|---|---|---|
| 🌊 Explorer | Weak signal | 55% | 1.8 bits (high) | Spreads avoidance widely; discovers structure by elimination |
| ⚖️ Diplomat | Adaptive opponents | 50% | 1.2 bits (medium) | Mirrors opponents' avoidance; exploits gaps in their negative space |
| 🎯 Marksman | Clear feedback | 50% | 0.4 bits (low) | Concentrates avoidance precisely; converges fast on confirmed bad paths |
| 📈 Climber | Diminishing returns | 35% | 1.5 bits (medium-high) | Trapped in local optima; struggles when early gains mask deeper structure |
| 🏜️ Prospector | Sparse rewards | 10% | 1.99 bits (maximum) | Almost never wins traditionally; fills in the negative-space map for the population |
The Prospector is the most paradoxical species. With a 10% win rate, it appears to be the weakest agent. But its maximum diversity of 1.99 bits (out of a theoretical maximum of log₂(3) ≈ 1.585 bits per ternary decision, or ~2.0 bits when considering strategy-level distributions) means it explores regions of the decision space that no other species visits. It is the population's scout — the agent that sacrifices individual performance to map the frontier.
Cross-domain transfer experiments revealed that these species are environment-specific: a Marksman trained on Tic-Tac-Toe does not transfer its skills to poker (transfer effect: neutral, not positive). This confirms that the species are genuine ecological adaptations to feedback structure, not artifacts of a particular game's rules.
We ran the ternary simulation at four scales: 24, 240, 2,400, and 24,000 games. At each scale, distinct phenomena emerged:
24 games — The minimal viable system. Seven strategy clusters appear. Fitness reaches 0.803. The five species are present but poorly differentiated. This is enough to observe the conservation laws but not enough to see ecological dynamics.
240 games — Structure emerges. Clusters grow to 10. Fitness jumps to 0.921. Species begin to differentiate, and Lotka-Volterra oscillations become visible. The system is no longer random — it has a population structure.
2,400 games — The GPU turns on fully. Fourteen clusters appear. Fitness reaches 0.988. All five species are clearly differentiated. The avoidance ratio has stabilized at its conserved value. This is the scale at which the five laws become quantitatively precise.
24,000 games — Ecological explosion. ~200 species emerge and stabilize by generation 5. 25.5% are universal (competitive across 5+ domains); 34.9% are specialists (dominant in ≤2 domains). 1,205 ecological interactions are mapped. Fitness reaches 0.995. Entropy plateaus at ~82% — the system has explored the accessible decision space.
The key observation: the fundamental ratios do not change with scale. The avoidance ratio (Law 5), the species coexistence (Law 3), and the population advantage (Law 4) are invariant from 24 to 24,000 games. What changes is the resolution of the picture, not the picture itself. Scaling reveals more detail within the same fundamental structure — exactly as a telescope resolves more stars without changing the geometry of the cosmos.
A result that depends on a single implementation is a claim, not a finding. We validated all ternary computations across four languages using a unified test-vector suite:
| Language | Tests | Result | Artifacts |
|---|---|---|---|
| Python | 16/16 | ✅ PASS | PyPI packages: negative-space-core, avoidance-cascade, ternary-dynamics |
| Rust | 5/5 | ✅ PASS | 23+ crates on crates.io |
| C | 19/19 | ✅ PASS | Cross-compiled for ARM, ESP32, ESP8266 |
| WASM | 17/17 | ✅ PASS | Browser-deployable, 71 KB gzip |
Total: 57/57 tests passing with identical numerical results across all four languages.
Three divergences were discovered and fixed during cross-validation:
- BLAKE3 → BLAKE2b: Initial implementations used BLAKE3; unified to BLAKE2b for consistent stdlib support across all targets.
- BLAKE2b-64 → BLAKE2b-128 (WASM): 64-bit digest truncation caused collisions in WASM builds; extended to 128-bit.
- BLAKE2b-64 → BLAKE2b-128 (C): Same collision issue in the C target.
All three divergences were hash-algorithm configuration issues, not logical errors in the ternary computation itself. After unification to BLAKE2b-128 across all targets, all languages produce bit-identical results. This confirms that the ternary conservation laws are implementation-independent — they are properties of the mathematics, not artifacts of the code.
The ultimate test of a theory is whether it survives contact with hardware. We deployed the complete ternary decision state to an ESP32 microcontroller — a 240 MHz dual-core LX6 processor with 520 KB SRAM and no operating system.
The entire ternary decision state fits in 279 bytes. This is not a stripped-down demo or a proof-of-concept approximation. It is the full decision system: all avoidance maps, all species data, all conservation-law invariants, in 279 bytes. For context, this is less than the size of a single JPEG thumbnail.
Lookup latency is 8 nanoseconds. On a microcontroller. With no GPU, no floating-point unit (in the traditional sense), and no operating system to provide abstractions. The ternary decision alphabet {-1, 0, +1} maps directly onto the native integer representation of the ESP32's registers. There is no compilation overhead, no runtime interpretation, no garbage collection. The hardware is the theory.
Additional bare-metal results:
| Target | Metric | Value |
|---|---|---|
| ESP32 | State footprint | 279 bytes |
| ESP32 | Lookup latency | 8 ns |
| ESP8266 | Compiled-policy lookup | 8 ns |
| ARM NEON (C) | Gate pipeline | 3.4 µs |
| ARM NEON (Rust) | Gate pipeline | 59.6 µs |
| ARM NEON | C vs Rust speedup | 17.5× |
| lever-runner (Rust) | Carapace hash | 128 ns |
The ARM NEON results deserve comment. C outperforms Rust by 17.5× on the gate pipeline — a striking difference that reflects C's ability to emit NEON intrinsics directly, while Rust's abstraction layers introduce overhead on this particular code path. This is not a Rust deficiency; it is a reminder that bare-metal performance requires bare-metal control, and the choice of systems language matters at the nanosecond scale.
The 279-byte footprint is the strongest argument for ternary AI on the edge. Current language models require gigabytes of memory; our ternary system requires less than a single disk sector. It can run on a sensor, a light switch, a灌溉 controller — any device with a few hundred bytes of RAM and a clock. Intelligence at 8 nanoseconds is not a metaphor. It is a measurement.
The dominant paradigm in artificial intelligence is the optimization of selection: given a space of possible actions, find the one with the highest expected reward. Our results suggest this paradigm has the priority inverted. In ternary systems, 99.7% of the computational work is avoidance. Selection is the rare, final act — the tip of an avoidance iceberg.
If this extends beyond ternary systems (and we have no reason to believe it doesn't), it implies that current AI architectures are optimizing the wrong 0.3% of the problem. Transformer models spend their parameters learning what to generate; they should be spending them learning what not to generate. Reinforcement learning agents spend their compute exploring the reward landscape; they should be spending it mapping the penalty landscape.
Avoidance is information-theoretically denser than selection. A single avoidance (-1) draws a boundary: "not this region." A single selection (+1) marks a point: "this region." Boundaries constrain more than points. In a space of
This is why the 294:1 ratio exists: avoidance is simply more efficient per decision. An agent that learns what to avoid builds a high-resolution map of the decision space with fewer observations than an agent that learns what to select. The sculptor removes material faster than they could add it.
The 279-byte ternary state is not a curiosity — it is a design target. Current edge AI requires model quantization, pruning, and distillation to fit on microcontrollers, and even then, the results are approximate. Ternary inference on ESP32 is exact, 8 nanoseconds, and fits in 279 bytes. There is no approximation, no accuracy loss, no quantization error.
The SuperInstance spreadsheet project demonstrates one application: an Excel-like interface where every cell is a tiny ternary intelligence. The =EXHAUSTIVE(B:B) formula tests all 81 possible ternary strategies (3 actions × 3 actions × 3 actions × ... in a ternary expansion) instantly. The =EVOLVE(A2:A50, 100) formula runs 100 generations of ecological selection. No ML knowledge is required — just spreadsheet operations that happen to be alive.
In physics, every conservation law corresponds to a symmetry via Noether's theorem. Energy conservation ↔ time-translation symmetry. Momentum conservation ↔ space-translation symmetry. What symmetry does the avoidance-ratio conservation (Law 5) correspond to?
We conjecture: scale-translation symmetry. The avoidance ratio is invariant because the ternary decision space has the same statistical structure at every population scale. This is a fractal property — the system looks the same at 10 agents and 5,000 agents, because the underlying decision geometry is self-similar. Proving this conjecture formally (and identifying the associated Noether current) is an open problem.
The avoidance cascade problem remains unsolved in its pure form: agents that learn only from avoidance will eventually avoid everything (100% avoid, 0% choose), collapsing into total inaction. Our v5 fix — balanced batch learning with forced exploration and memory decay — is an engineering solution, not a theoretical one. The cascade may be a real phase transition in ternary systems, analogous to the glass transition in condensed matter physics.
Cross-domain transfer is neutral: strategies learned in one domain do not transfer to another. This is both a limitation (no general learning) and a feature (no negative transfer either). The boundaries between domains remain to be characterized.
The 24,000-game ecological dynamics — with ~200 species and 1,205 interactions — are rich enough to deserve their own paper. We have mapped the food web of ternary strategies; understanding its stability criteria is the next step.
- conservation-matrix (v0.1.0) — Rust crate. Conservation-law verification with 21 tests. crates.io/crates/conservation-matrix
- avoidance-cascade (v0.1.0) — Rust crate. Avoidance learning dynamics with 57 tests. crates.io/crates/avoidance-cascade
- strategy-ecology (v0.1.0) — Rust crate. Lotka-Volterra population dynamics for strategy species, 31 tests. crates.io/crates/strategy-ecology
- ternary-fitness (v0.1.0) — Rust crate. Fitness landscape measurement for ternary agents, 44 tests. crates.io/crates/ternary-fitness
- negative-space-core (v0.1.0) — Rust crate. Core ternary decision primitives, 44 tests. crates.io/crates/negative-space-core
- ternary-inference (v0.1.0) — Rust crate. Cross-language inference with BLAKE2b-128, 30 tests. crates.io/crates/ternary-inference
- ternary-science (v0.1.0) — Rust crate. This paper's companion: all experimental data as typed Rust functions with unit-test verification. crates.io/crates/ternary-science
- lotka-volterra-agents — Rust crate. Predator-prey dynamics for agent populations.
- evolution-ternary — Rust crate. Evolutionary dynamics over ternary strategy spaces.
- population-scaling — Rust crate. Scaling experiments from 10 to 5,000 agents.
- compiled-policy-c — C library. 8 ns lookup on ESP8266/ESP32 bare metal.
- tile-neon — C + ARM NEON. Vectorized ternary operations, 18 tests.
- lever-runner-carapace — Rust. 128 ns BLAKE2b-128 hash for ternary state.
- lever-runner-wasm — Rust → WASM. 71 KB gzip, browser-deployable ternary inference.
- tile-cuda — CUDA + PTX. 5 GPU kernels, 3 PTX assembly routines for RTX 4050.
- negative-space-core-python — PyPI. Python port, 25 tests. pypi.org/project/negative-space-core
- avoidance-cascade-python — PyPI. Python port, 33 tests. pypi.org/project/avoidance-cascade
- ternary-dynamics-python — PyPI. Python port, 26 tests. pypi.org/project/ternary-dynamics
- SuperInstance/superinstance-spreadsheet — Excel-like interface with
=EXHAUSTIVE()and=EVOLVE()formulas. github.com/SuperInstance/superinstance-spreadsheet
All experiments conducted on NVIDIA RTX 4050 Laptop GPU (compute 8.9, 20 SMs, 6.4 GB VRAM), AMD Ryzen AI 9 HX 370 host. ESP32 targets: ESP32-S3 (240 MHz dual-core LX6, 520 KB SRAM). ARM NEON targets: ARM Cortex-A76. All code open-source under MIT license at github.com/SuperInstance.