JX N-Body Engine 0.1.0: Arbitrary-Precision Python and Numerical Validation

Lino Avila — Fri, 21 Aug 2026 04:45:15 +0000

A Newtonian N-body engine built around a sixth-order Yoshida integrator, an independent Decimal Bulirsch-Stoer reference, and conservative scientific claim controls.

By Lino Avila | JX Planet X project | August 2026

JX N-Body Engine 0.1.0 is a reusable Newtonian propagation and numerical-validation toolkit written in Python. It grew out of the JX Planet X investigation, but its purpose is broader: to make high-precision N-body experiments reproducible, inspectable, and difficult to overinterpret.

The software is not evidence of a Planet X detection. The original investigation remains unresolved. Passing a numerical gate shows that a calculation behaved as specified; it does not establish that an astronomical source exists.

Evidence classification: MODEL_OUTPUT / numerical validation

Claim decision: SCREENING_ONLY

Numerical status: PRODUCTION_NUMERICAL_GATE_PASSED

Latest source-inference status: BLOCKED_SOURCE_POPULATION_NONCONVERGENCE

License: MIT

Why I built a second numerical path

High-precision output is not automatically trustworthy. A result can contain many digits and still be wrong because of an implementation error, an unstable method, an incorrect frame, or an unsupported scientific interpretation.

JX therefore uses two deliberately different propagation foundations:

A sixth-order symmetric Yoshida composition. This is the primary fixed-step symplectic path. Its coefficients are stored as decimal strings, and adjacent kick stages are merged so each macro-step requires eight force evaluations.
An independent Decimal Bulirsch-Stoer implementation. This uses modified midpoint integration and extrapolation as a separate reference path. It does not reuse the Yoshida stepping logic.

Agreement between independent methods is stronger evidence of numerical correctness than agreement between two precision settings of the same implementation. It is still only numerical evidence.

What the release contains

The Python package is organized into focused, auditable modules:

decimal_math.py: Decimal construction, three-dimensional vector operations, and a small analytic sine/cosine kernel used by validation problems.
dynamics.py: deterministic Newtonian accelerations, state management, and energy and angular-momentum diagnostics.
yoshida6.py: the sixth-order symmetric Yoshida integrator and force-evaluation accounting.
decimal_bs.py: the independent arbitrary-precision Bulirsch-Stoer reference integrator.
ias15_gate.py: optional adaptive IAS15 convergence tests through REBOUND.
gates.py: analytic convergence, coefficient closure, two-body invariant, and force-count gates.
claims.py: evidence labels and a conservative decision state machine.
provenance.py: source hashes, environment records, and run-record generation.
production_benchmark.py: locked benchmark verification and cross-trajectory comparisons.
de441_anchor.py: import and validation of a transparent DE441-anchored benchmark state.
cli.py: command-line access to validation and reproduction workflows.

The complete executable source, tests, benchmark inputs, machine-readable results, and checksum manifest should be downloaded from the versioned release linked at the end of this article. Publishing the source as an archive rather than as formatted article text preserves ASCII characters, indentation, and file boundaries.

Core numerical gates

The core validation suite encodes its acceptance criteria in the software rather than relying on a visual judgment of trajectories. The preserved version 0.1.0 run produced the following results:

Gate	Measured value	Encoded acceptance criterion	Result
Yoshida coefficient closure	0 at stored precision	Exactly zero	PASS
Analytic oscillator convergence	64.00069	Between 60 and 68; sixth-order expectation is 64	PASS
Two-body energy	8.68e-27 relative drift	Less than 1e-12	PASS
Two-body angular momentum	2.0e-79 relative drift	Less than 1e-60	PASS
Optimized force count	8,000	Exactly 8,000	PASS

The oscillator test compares the propagated phase-space state against independently evaluated Decimal sine and cosine values. That matters because a symplectic map can preserve a phase-space norm unusually well even when its phase is wrong.

Production benchmark and independent comparison

The preserved production workflow adds stronger checks around the core unit-scale tests. It verifies the benchmark manifest, reruns 160-bit and 224-bit Yoshida members, compares serialized trajectories, and checks the higher-precision Yoshida output against an independently preserved Bulirsch-Stoer reference.

The encoded production criteria include:

projected 30,000-year wall time no greater than 4,500 seconds for the locked benchmark configuration;
oscillator error ratio between 60 and 68;
relative energy drift no greater than 1e-9;
relative angular-momentum-vector drift no greater than 1e-10;
exactly 5,000 macro-steps and 40,000 force evaluations;
bounded cross-precision and cross-method trajectory differences;
zero bound/unbound classification mismatches.

The final 100-year DE441 numerical audit used an independent 78-decimal-digit Bulirsch-Stoer reference. It completed in 232.0 seconds and reported:

relative energy drift of 5.47e-35;
relative angular-momentum drift of 1.03e-35;
a maximum Yoshida-versus-Bulirsch-Stoer massive-body position difference of 3.77e-11 AU, against a 1e-7 AU gate;
zero bound-state mismatches;
exact agreement of the repeated massive-body paths across all fifteen massless-tracer blocks.

The complete release record reports thirteen packaged tests passed. The numerical status is PRODUCTION_NUMERICAL_GATE_PASSED. These are numerical acceptance results, not observational findings.

A transparent DE441-anchored test

The DE441 workflow constructs a 20-body benchmark containing the Sun, Jupiter, Saturn, Uranus, Neptune, and fifteen massless synthetic tracers. The preserved epoch is TDB Julian Date 2461200.5 in J2000 ecliptic axes.

The benchmark distinguishes its inputs explicitly:

the massive-body state is classified as RECONSTRUCTED from a preserved DE441 source;
the synthetic tracer population is classified as an ASSUMPTION;
the propagated trajectories are classified as MODEL_OUTPUT.

Before the independent reference was added, the 160/224-bit Yoshida precision pair already produced a massive-body position mismatch of 3.66e-44 AU, zero bound-state mismatches, and a relative energy drift of 6.59e-17. Its projected 30,000-year runtime was 1,861 to 2,269 seconds. The independent 78-digit Bulirsch-Stoer run then closed the numerical gate.

Even though the numerical comparisons passed, the final decision remains SCREENING_ONLY because numerical propagation cannot establish an observed source.

The gate that correctly failed

A useful scientific engine must reject an attractive result when its prerequisite convergence fails. JX did exactly that in the subsequent 100,000-year IAS15 population test.

The matched no-source population converged, with 0.0295 AU disagreement. The middle compact-source population did not converge:

mean-perihelion disagreement: 0.1457 AU, against a 0.1 AU gate;
Wasserstein-perihelion disagreement: 0.1551 AU, against a 0.1 AU gate;
bound-state mismatches: zero;
pointwise trajectories became chaotic after approximately 39,000 to 95,000 years.

The governing result was BLOCKED_SOURCE_POPULATION_NONCONVERGENCE. The apparent source effect was therefore excluded from scientific use. This does not reject every compact-source model; it rejects an inference drawn from that nonconverged fifteen-trajectory population.

This failed gate is evidence that the claim controller is functioning as intended. The software passed its numerical foundation tests while refusing to convert an unstable model comparison into a Planet X claim.

Running the core validation

After downloading and verifying the release archive, run the core suite from the project root:

PYTHONPATH=src python3 -m jxplanetx.cli validate \
  --decimal-digits 80 --output runs/validation.json

To reproduce the locked Yoshida benchmark:

PYTHONPATH=src python3 -m jxplanetx.cli reproduce-yoshida6 \
  --bundle-dir PATH_TO_VERIFIED_BUNDLE \
  --run-dir runs/yoshida6_reproduction \
  --output runs/yoshida6_reproduction.json

The command should return a nonzero exit status when a required gate fails. The JSON run record preserves the configuration, gate results, evidence classification, environment, and source manifest.

Important limitations

JX 0.1.0 is intentionally narrow. Readers should understand the following boundaries before using it:

The core implements Newtonian point-mass dynamics. It does not include relativistic, nongravitational, oblateness, or other production ephemeris forces.
Massless tracers do not exert force on massive bodies.
Coincident positions are treated as collisions and stop the calculation; the core has no collision regularization.
The current Decimal sine/cosine validation kernel accepts arguments with absolute value no greater than one.
Some derived quantities, such as inclination through acos, use binary floating-point transcendental functions and are judged numerically rather than byte-for-byte.
The optional REBOUND/IAS15 path is a separate adaptive comparison path, not an arbitrary-precision Decimal implementation.
Long chaotic integrations require population-level and source-minus-control convergence tests; a single trajectory match is not sufficient.

These limitations are part of the scientific record, not footnotes to be hidden.

Reproducibility and provenance

Every published release should include:

the exact source archive and its SHA-256 hash;
a checksum manifest covering source, tests, documentation, and benchmarks;
the Python version, platform, dependency versions, and runtime configuration;
the initial states, trajectory files, summaries, and run logs used for each reported result;
a machine-readable statement of passed, failed, and missing gates;
the precise distinction between measured data, reconstructed inputs, assumptions, model output, and speculation.

The source-only archive hash associated with version 0.1.0 is:

9c478f9006d4a3aaa08676f4c61da291e9b961654ff5114b70907a5cc7d6b8c2

Readers must compare this value with the downloaded archive before treating it as the release discussed here.

The preserved complete JX research archive, including equations, tests, benchmark inputs, results, and reproduction instructions, has SHA-256:

286a6b834bb2df509b1ce0a83e21ac90112306a43ea98c997d2308c2be579fa8

The source-only archive and complete research release are different artifacts and should be labeled separately on the public release page.

Download, review, and license

The public release is available from these permanent links:

JX N-Body Engine 0.1.0 is released by Lino Avila and the JX Planet X project under the MIT License. Preserved third-party material retains its included licenses and notices. Modifications should preserve evidence labels, failed gates, unresolved blockers, and claim limits. Technical review is especially welcome on the Yoshida composition, independent Bulirsch-Stoer path, benchmark provenance, and the boundaries between numerical and observational evidence.

Editorial disclosure: This article was prepared with OpenAI Codex assistance under Lino Avila’s direction and reviewed against the preserved JX source code, tests, numerical results, and release checksums.

DEV Community: Lino Avila