ARCO

Automated Research into Computational Ontologies

ARCO is a computational science platform that 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, and schedule — and measures emergent computation via shuffle-corrected normalized mutual information calibrated against destructive null distributions. ARCO does not assume classical, quantum, or neural computation as fundamental. All known paradigms are treated as phenomena to be explained, not primitives to be assumed.

Key Findings

How It Works

ARCO runs a six-step scientific cycle on any system that implements the InformationUniverse trait:

1. Generate — sample rule sets spanning a spectrum from purely destructive to purely structured.
2. Calibrate — establish detection thresholds from a null distribution of information-scrambling rule sets.
3. Observe — generate ensembles of trajectories and compute storage, memory, and persistence via shuffle-corrected mutual information.
4. Hypothesize — formulate falsifiable structural hypotheses (e.g., "rules with property X exhibit storage above threshold").
5. Test — evaluate hypotheses on held-out universes, penalizing complexity via minimum description length.
6. Revise — discard falsified hypotheses, retain survivors, check failure conditions.

Getting Started

Installation

# Add to your Rust project
cargo add arco

# Or build from source
git clone https://github.com/kvernet/arco.git
cd arco
cargo build --release

Requires Rust 1.85+.

Quick Start

# Run the Binary Graph Universe experiment
cargo run --example binary_graph_cycle --release

# With a custom seed
cargo run --example binary_graph_cycle --release -- 99

# Run the Cellular Automata discovery experiment
cargo run --example ca_discovery --release

# Minimal example using the core traits
cargo run --example minimal_cycle --release

Use as a Library

use arco::substrates::graph::{
    BinaryGraphUniverse, generate_standard_hypotheses,
    spectrum_rule_generator, verify_boolean_functions,
};
use arco::cycle::{CycleConfig, run_cycle};

let mut rng = StdRng::seed_from_u64(42);
let universe = BinaryGraphUniverse::new(3, "compound", &mut rng);
let config = CycleConfig::default();
let mut hypotheses = generate_standard_hypotheses();
let mut generator = spectrum_rule_generator(400, 42);
let record = run_cycle(&universe, &config, &mut hypotheses, &mut generator, None);
println!("{}", record.summary());

Documentation

• Mathematical Constitution — the formal specification of Information Universes, emergence metrics, and the scientific cycle
• API Documentation — rustdoc for the latest release
• Examples — runnable usage examples
• GitHub Repository

Architecture

ARCO's core is substrate-independent. The Binary Graph Universe and Cellular Automata experiments use the same generic traits and the same scientific cycle without modification.

Substrates implement these traits. The scientific cycle operates on any InformationUniverse. The Binary Graph substrate ships with ARCO. The CA experiment demonstrates adding a new substrate in a single file.

Python Reference

The methodology was first validated in a Python reference implementation. It reproduces the Structure-Storage Gradient and the Transport Law independently of the Rust version. arco-python on GitHub.

Limitations & Honesty

• The plugin mutual information estimator has known small-sample bias. Shuffle correction mitigates but does not eliminate it.
• Hypothesis accuracies at n=300 can vary ±20 points across seeds. Larger experiments (n=10,000+) provide stable estimates.
• The Binary Graph Universe is a validation substrate — it uses hand-coded rules to calibrate the measurement apparatus. Discovery substrates (unlabeled rules) are the next research milestone.
• The CA experiment demonstrates paradigm-neutrality on a second substrate but does not yet implement the full InformationUniverse trait — it calls metrics directly.
• All findings are from small state spaces (3-vertex graphs, 8-cell automata). Scaling to larger universes is ongoing.