Skip to content

Repository files navigation

#G-A-S-O-I-R-E (Galilean-Aristotelian-Sampling-Observational-Inductive Reasoning Engine)

Dissolving apparent autonomy into mechanisms — with every published number regenerated by code.

ci Python 3.11+ License: MIT License: CC-BY-4.0 Reproducibility ORCID

An exercise in computational epistemology: convert "self-generated" behavior into causal mechanism, and hold every claim to the standard of mechanical reproduction.


What this is

OIRE is a research architecture and benchmark suite built around one operation: dissolving apparent autonomy. Given a phenomenon described as self-generated — a moon that "rotates on its own axis," a market that "recovers by itself," a bulb that "responds to a distant observer" — the engine produces a causal explanation of exactly three kinds:

Mechanism What it means Example
Externally forced automaton An outside driver accounts for the behavior AC currents drive an "idle" motor
Reference-frame artifact The motion is a coordinate-system illusion Tidal locking: the Moon has no net rotation in the Earth-fixed frame
Poised-critical detector The system sits near a threshold that amplifies tiny perturbations A bulb reacting to a hand two meters away

…or it flags an explicit residual: "information insufficient" — because an engine that never says "I don't know" is not reasoning, it is confabulating.

The repository evaluates this idea three ways, end to end, from pinned seeds:

  1. Symbolic engine suite — 20 labeled phenomena across five domains, including five insufficient-information cases whose correct behavior is a flagged residual.
  2. Galileo Active-Observer benchmark — reconstruct Io's orbit from ≤12 noisy angular samples under a simplified 1610 observing geometry; five sampling policies compared in a paired Monte Carlo design (N=200 per noise level × 6 noise levels), including a structural-memory ablation.
  3. Cross-domain transfer — one causal skeleton (damped driven oscillator) instantiated as pendulum / RLC circuit / population dynamics; warm-vs-cold identification across all ordered domain pairs (N=100 each).

Headline findings (measured, not projected)

These are the values this repository's code actually produces. Where they contradict the 2026 design drafts, the drafts lost. See PROVENANCE ledger.

  1. Structural memory is the dominant effect. Removing the analogizer prior degrades orbit-reconstruction accuracy ×1.29 and convergence speed ×1.32 versus the warm baseline — confidence intervals disjoint from every warm-started condition.
  2. Fancy sampling ≠ better sampling. Extrema-targeted active sampling shows no significant gain over uniform sampling at benchmark scale (Δ = −0.0019°, 95% CI [−0.0042, +0.0003]); uncertainty-driven (bootstrap-disagreement) sampling attains the lowest RMSE but with overlapping intervals — suggestive, not conclusive.
  3. Naive cross-domain transfer fails instructively. Generalization score 0.00: transferred priors never meet the ≥20%-acceleration criterion and actively harm far-domain pairs (up to 9× longer training) — a clean, quantitative demonstration of the false-analogy failure mode.
  4. The engine meets its specification exactly: 100% classification on determinate cases, 100% residual-flagging on indeterminate ones — validating implementation fidelity, honestly framed as such.

Results

Policy RMSE@30d (deg) 95% CI Samples to converge
baseline_uniform 0.0104 [0.0091, 0.0118] 6.3
varA_active_extrema 0.0123 [0.0106, 0.0142] 5.8
varB_conservative 0.0158 [0.0142, 0.0174] 6.6
varC_graph 0.0095 [0.0084, 0.0106] 6.3
varD_coldstart 0.0135 [0.0115, 0.0156] 8.4

Reference noise σ = 0.01° · Active-sampler accuracy gain vs baseline: -0.0019° (95% CI [-0.0042, 0.0003]) · Convergence delta: 0.48 samples (95% CI [-0.07, 1.02]) Generalization score: 0.00 · Engine classification accuracy: 100.0% · Insufficient-info flag rate: 100.0%

All values generated by experiments/ from pinned seeds — see results/*/manifest.json. Reproduce with make reproduce.

Benchmark figures (generated by experiments/run_galileo.py)
RMSE vs noise Convergence
RMSE@30d vs measurement noise, by policy Mean samples to converge, σ = 0.01°

The reproducibility contract

Most research repos say "code coming soon." This one makes reproduction a mechanical property:

make setup          # pip install -e ".[dev]"  (Python ≥ 3.11)
make test           # 80 tests, 99% coverage on the package
make experiments    # regenerate EVERY result from seed 20260826
make emit           # regenerate paper tables/macros + the README block above
make reproduce      # re-run everything; fail on any byte-level drift
  • Every experiment writes a manifest: git SHA, environment versions, seeds, SHA-256 of every output file.
  • CI re-runs all experiments from scratch and fails if any published hash drifts.
  • Every table and number in the paper is \input from generated files — zero hand-transcribed values anywhere.
  • Wall-clock timings live in unhashed manifest metadata only; hashed outputs are deterministic by construction.

Repository map

Path Contents
oire/engine/ Layer 1 — symbolic autonomy-dissolution engine (v2.0 reference implementation)
oire/observer/ Layer 2 — vectorized Kepler propagation, sampling policies, bounded multi-start estimation
oire/transfer/ Layer 3 — causal-skeleton transfer protocol with shrunk priors
experiments/ Seeded runners + artifact generation (tables, macros, README block)
results/ Committed outputs with SHA-256 provenance manifests
paper/ LaTeX source → PDF via CI (\inputs generated tables only)
docs/ Architecture · Methodology · Reproducibility · Provenance ledger
docs/legacy/, media/legacy/ Original 2026 drafts & media, preserved verbatim

Documentation

  • Architecture — module map, data flow, design rules
  • Methodology — the six-step generative design method; corpus-derived provenance stated openly (historical texts used as design stimuli, not sources of claims)
  • Reproducibility — seeds, overrides, CI semantics
  • Provenance ledger — projected (drafts) vs measured (this repo), claim by claim — including the claims that did not survive

Citation

If you use this work, please cite:

@software{robinson2026oire,
  author = {Robinson, Michael Forsythe},
  title = {OIRE: Autonomy-Dissolver Reasoning Engine},
  year = {2026},
  version = {0.1.0},
  orcid = {0009-0002-8487-759X},
  url = {https://github.com/Michaelrobins938/oire}
}

See also CITATION.cff.

License

Code: MIT · Paper & docs: CC-BY-4.0

Author

Michael Forsythe Robinson — Independent Researcher

ORCID 0009-0002-8487-759X · GitHub @Michaelrobins938 · forsythepublishing@gmail.com

About

Autonomy-Dissolver Reasoning Engine: causal discovery that converts apparent autonomy into mechanism — with CI-verified, seed-exact reproduction of every published number.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages