ARCO

Automated Research into Computational Ontologies

A computational science platform for discovering the conditions under which computation, memory, and learning emerge in arbitrary information systems.

What ARCO Does

ARCO asks a different question than most computer science: not "what can a given computational model compute?" but "what computational models are possible, and why do they emerge?"

It formalizes this through Information Universes — 6-tuples of (state space, transformations, observations, resources, invariants, schedule) — and measures emergent computation via shuffle-corrected normalized mutual information calibrated against destructive null distributions.

Installation

As a library

Add to your Cargo.toml:

[dependencies]
arco = "0.2"

From source

git clone https://github.com/kvernet/arco.git
cd arco
cargo build --release

Requires Rust 1.85+.

Quick Start

use arco::cycle::{CycleConfig, run_cycle};

fn main() {
    let config = CycleConfig::default();
    let record = run_cycle(&config);
    println!("{}", record.summary());
}

Or via the CLI:

cargo run --release
cargo run --release -- --train 1000 --test 300 --seed 42
cargo run --release -- --quick

See examples/ for more usage patterns.

Experimental Findings

All results below are at n=10,000 training universes with 2,000 held-out test universes, across 10 independent seeds. The current Binary Graph Universe is a validation substrate — it uses hand-coded computational primitives to calibrate ARCO's measurement apparatus. See the Mathematical Constitution for the distinction between validation and discovery substrates.

Structure-Storage Gradient

Storage probability increases monotonically with the fraction of structured rules. This is ARCO's most robust finding.

Full spectrum across all 10 seeds:

Structural Hypotheses

These hypotheses test whether specific structural properties of rule sets predict storage. All consistently outperform chance (50%) at large sample sizes.

H5 — Transport Law: Rule sets containing information transport operations (PROPAGATE, SWAP, COPY_TO_OUT, COPY_FROM_IN) exhibit storage.

Range: 55.8 – 82.3%. Mean: 69.5%.

H2 — Majority Structure: Majority-structured rule sets exhibit memory.

Range: 59.9 – 82.0%. Mean: 72.0%.

H7 — Multiple Logic: Rule sets with at least two logic gates exhibit memory.

Range: 55.5 – 81.5%. Mean: 69.3%.

H3 — Logic Gate: Rule sets containing at least one logic gate exhibit memory.

Range: 53.6 – 73.6%. Mean: 63.0%. H3 failed to survive at seed 256 (below 50% threshold). Survives at 9 of 10 seeds.

Negative Control

H6 — All Destructive: Rule sets composed entirely of destructive rules should not exhibit emergence. This hypothesis consistently fails across all seeds, validating the null-distribution calibration.

Boolean Function Verification

NAND, AND, OR, NOR, and XOR gates are verified to function under stochastic, asynchronous, first-match scheduling — confirming that logical computation can be robust to nondeterministic rule ordering. These gates are hand-coded in the current Binary Graph Universe as part of the validation substrate.

Statistical Notes

• The plugin mutual information estimator has known small-sample bias. Shuffle correction (10 permutations) subtracts the mean baseline. For larger state spaces, a Bayesian (NSB) or Miller-Madow estimator is recommended.
• Hypothesis accuracies at n=300 can vary by ±20 percentage points across seeds. The n=10,000 estimates above are stable to within ~5 points.
• Earlier reports of 91.2% H5 accuracy from the Python reference implementation (n=300, seed=42) were a high-variance draw at small sample size. The large-n Rust estimates are more reliable.

Performance

Benchmarked on a 20-core machine (release build):

Package Structure

Documentation

• Mathematical Constitution — the formal specification
• API documentation — rustdoc for the latest release
• Examples — runnable usage examples

Python Reference

The Python reference implementation that first validated the methodology is available at arco-python.

License

MIT