Research-derived mathematics for Neuroca.

VoidKit is a growing scientific-computing and mathematics library built from the reusable mathematical machinery developed across Neuroca research.

It is broader than any one theory or model. VDM is one source family, not the definition of the package. Phase Calculus is another major research line, and many tools in VoidKit are intended to stand independently as numerical, algebraic, statistical, geometric, graph, dynamical, symbolic, or exact-computation utilities.

The project exists to turn research code into durable tools without erasing where the mathematics came from or what made an implementation distinctive.

Current status: early development / active extraction. The repository is usable as a research library, but the public API is not yet stable and substantial material is still being reconciled from the mining corpus.

Why VoidKit exists

Research tends to produce useful mathematics in inconvenient places: experiment scripts, validators, derivation notebooks, one-off solvers, native kernels, symbolic audits, and prototype implementations.

VoidKit is the refinery for that material.

The goal is to recover useful mathematical capability and give it a clean, tested, discoverable home while preserving:

• the original mathematical contract and assumptions;
• authored mechanism and method identity;
• derivational and implementation provenance;
• exact arithmetic, invariants, certificates, and validation gates when they matter;
• alternate historical/native/symbolic sources may be retained as evidence and provenance, but production mathematics has one authoritative Rust implementation;
• uncertainty honestly, including cases where novelty or canonical status is still being assessed.

A familiar-looking implementation is not automatically redundant. A research-derived method is compared on its actual mathematics, algorithm, evidence, and behavior before it is generalized, replaced, or retired.

Scope

VoidKit is being developed as a broad mathematics and scientific-computing library. Current and planned capability families include:

Area	Examples
Numerical methods	root finding, interval certification, ODE/PDE methods, spectral operators, exact finite-time flows
Exact & discrete mathematics	permutations, free groups, Heisenberg structure, arbitrary-width arithmetic, Fibonacci/balanced refinement
Dynamical systems	nonlinear flows, reaction-diffusion, finite-relaxation transport, sparse/asynchronous fields
Graphs & networks	propagation diagnostics, causal/event structures, matching, spectral tools, sparse field dynamics
Statistics & information	correlated-series statistics, heavy-tail analysis, divergence and information measures
Geometry & topology	symbolic geometry, lattice/refinement tools, topology, recurrence and structural diagnostics
Wave & field methods	Klein-Gordon tools, pseudospectral methods, conservation/Noether diagnostics
Symbolic & certification tools	symbolic identity checks, algebraic-root certification, enumerative/symbolic search
VDM	authored VDM mechanisms and mathematics, including SIE and RE-VGSP, kept under their own identity
Phase Calculus	QBL, Orthad, exact coordinates, transport, FQM/cocycle machinery, certificates, native kernels, and Phase-native computation such as the π spigot/streamer family

This list describes the project direction, not a claim that every listed capability is already merged into the public API.

Research custody

VoidKit follows a few strict rules:

1. Portable does not mean generic. A method can be reusable outside its parent research program and still remain an authored method.
2. Generalization is additive. If a generic primitive can be extracted from an authored mechanism, the primitive may be exposed separately without replacing the authored object.
3. Novelty is not a packaging gate. Some items are known methods, some are distinctive implementations, and some may warrant novelty review. Unassessed novelty does not block preservation, testing, or use.
4. Source semantics outrank cleanup convenience. API cleanup does not authorize changing equations, branch behavior, certificates, invariants, or other load-bearing mathematics.

The detailed mining and custody rules live in MATH_MINING_TODO.md.

Current development state

VoidKit is currently at v0.1.1 (pre-alpha) and should be treated as an evolving research library.

The active math-mining ledger tracks 326 retained code/support sources from the current VDM Math Mining v3 corpus. Those sources range from general-purpose mathematical utilities to large Phase Calculus families, native kernels, VDM mechanisms, symbolic verification code, and research implementations still awaiting reconciliation.

A few important consequences:

• APIs may move while the package is being organized by mathematical ownership.
• voidkit.vdm is reserved for VDM-specific authored mechanisms and mathematics.
• voidkit.phase_calculus is the dedicated Phase Calculus namespace. Its first foundation pass now includes exact balanced refinement certificates, the Q/B/L custody law, and the execution-free Orthad closed-form read surface; later Phase families remain under staged recovery.
• historically useful but non-canonical VDM experiments may be retained under voidkit.vdm.easter_eggs.
• mining archives under sources/ are provenance/research material, not automatically public API.

For the current extraction state and planned work, see MATH_MINING_TODO.md.

The prior validated extraction work is now restored in two custody-preserving passes. The first covers algebra, interval/spectral/Klein-Gordon, Yin-Yang, and exact-logistic primitives. The second reconciles the 27-module ore-extraction family into current capability owners, including PDE, statistics, information theory, graph, wave/Noether, recurrence, topology, signal, thermodynamics, special-function, and variational tools. Duplicate historical namespaces were deliberately not recreated. Phase Calculus foundation pass 01 then separates general Fibonacci/balanced arithmetic into voidkit.algebra, preserves Phase-specific resolution certificates in voidkit.phase_calculus.refinement, retains a narrow arithmetic projection of the direct B/Q/L recurrence, and restores an execution-free derived Orthad read surface. The current authored lifted-object walkthrough is the semantic authority: there is no external primitive selector law, primitive custody is the current U_t in {B,Q,L}, and the full lifted object remains a separate implementation target.

Native Navier–Stokes and Fourier tools

voidkit.pde.navier_stokes exposes the retained CF10 F1.A periodic 3-D equations, RK4 evolution, initialization, and shell diagnostics. Arbitrary-length Fourier transforms and the existing spectral derivatives now execute in Rust. The shared complex type preserves the lifted-quintic engine's ownership and compatible import path. See the API contract and Pass07 closeout.

Installation

VoidKit is not currently presented as a stable PyPI release. For the Pass07 release, extract the release bundle and install from its wheel directory into an environment with NumPy and SciPy already available:

python -m pip install --no-index --find-links . --upgrade voidkit==0.1.1

The bundle contains Linux x86-64 native wheels for CPython 3.12 and 3.13 (glibc 2.34 or newer), plus the Python interface wheel. Runtime validation was performed on CPython 3.12; the 3.13 wheel was built and statically inspected. Build from source for other interpreter/platform combinations.

For a source checkout, build the matching native backend before installing the Python interface:

git clone https://github.com/Neuroca-Inc/voidkit.git
cd voidkit

python -m venv .venv
source .venv/bin/activate

python -m pip install --upgrade pip
python -m pip install maturin
(cd rust-wheel && maturin develop --release)
python -m pip install -e .

Optional dependency groups can be installed as needed:

python -m pip install -e ".[symbolic]"
python -m pip install -e ".[graphs]"
python -m pip install -e ".[tda]"
python -m pip install -e ".[phase]"
python -m pip install -e ".[vdm]"

For a full research checkout, including all current optional Python dependencies:

python -m pip install -e ".[full]"

Python 3.9+ is supported by the package metadata. pyproject.toml is the dependency and package-metadata authority; requirements.txt is only a convenience full-development environment.

A small current example

The repository already includes conventional utilities alongside research-derived mathematics:

from voidkit.advanced_math import descriptive_stats

data = [1, 2, 3, 4, 5]
stats = descriptive_stats(data, ddof=1)

print(stats["mean"])
print(stats["std"])

Current CLI entry points include:

voidkit-stats 1 2 3 4 5 --json
voidkit-diff "sin(x)**2 + x**3" --var x --order 1

VDM-specific entry points and APIs live under voidkit.vdm. Phase Calculus foundations now live under voidkit.phase_calculus, with later APIs promoted only when their canonical research contracts are established.

A current exact Phase/QBL example:

from voidkit.phase_calculus import QBLState, step

state = QBLState()
receipt = step(state)
print(receipt.primitive.name, receipt.after)

The Orthad read surface requires the lightweight phase extra because it uses arbitrary-precision mpmath arithmetic:

from voidkit.phase_calculus.orthad import OrthadClosedForm

orthad = OrthadClosedForm.at_tick(1000)
print(orthad.state)

A current Rust-owned exact-arithmetic example:

from voidkit.exact import BigNat, GaussianRational

a = BigNat((1 << 256) + 17)
b = BigNat((1 << 129) + 9)
q, r = divmod(a * b, a)
assert q == b and int(r) == 0

z = GaussianRational(6, -12, 18)
assert z.parts == (1, -2, 3)

Package map

The repository is intentionally broader than the original VDM-oriented README suggested.

voidkit/
├── advanced_math/
├── algebra/
├── causal_inference/
├── clustering/
├── dynamical_systems/
├── dynamics/
├── evolutionary/
├── exact/
├── fractal_analysis/
├── fractional_calculus/
├── graph/
├── iit/
├── info_theory/
├── neuro/
├── numerical/
├── optimization/
├── ot/
├── pathway_analysis/
├── pde/
├── phase_calculus/
├── provenance/
├── recurrence/
├── rmt/
├── sde/
├── semantic/
├── signal/
├── soc_analysis/
├── special/
├── stats/
├── structure/
├── spatial/
├── stochastic/
├── structural_plasticity/
├── symbolic/
├── tda/
├── thermodynamics/
├── time_series/
├── topology/
├── variational/
├── vdm/
└── wave/

The exact module organization will continue to improve as mined capabilities are reconciled and promoted.

Python and Rust

VoidKit’s production architecture is Python public interface → PyO3 → authoritative Rust backend. Python modules provide the public API, validation/normalization where appropriate, and presentation objects; substantive mathematical algorithms belong in Rust. Existing Python mathematical implementations are migration debt and are replaced capability-by-capability rather than preserved as fallback engines.

Current completed migrations under that boundary include VoidKit-owned dense partial-pivoting linear solves, adaptive Simpson/Richardson definite integration, a Dormand-Prince RK45 initial-value ODE solver with adaptive error control, backward integration, and exact requested-time stepping, a weighted one-dimensional Wasserstein-1 distance implemented as a native empirical-CDF sweep, arbitrary-width exact BigNat, BigInt, ExactRational, and normalized GaussianRational arithmetic, exact Sturm distinct-real-root counting/isolation/certification, and the authored lifted Bring-quintic all-roots certificate surface. Integer Bring coefficients cross-link real roots to the exact Sturm certificates rather than replacing exact real-root authority with floating root iteration. Their Python modules delegate to PyO3 rather than executing a second mathematical implementation.

The mining corpus may retain Python, Rust, C, assembly, and symbolic sources as provenance, fixtures, or independent evidence. Those source variants do not become parallel production authorities.

The deeper mining backlog is intentionally not considered exhausted by these migrations. MATH_MINING_TODO.md contains a prominent high-priority treasure-trove section covering the remaining exact/certificate families and deeper quintic evidence, Navier-Stokes and spectral kernels, graph/sparse dynamics, symbolic/enumerative machinery, information/fractional/TDA surfaces, and deferred Phase/Cortex mathematics located through the Orchestra index.

See RUST_README.md for the current Rust-side notes.

Roadmap

The repository-wide math roadmap is maintained in:

MATH_MINING_TODO.md

That document tracks:

• every retained item in the current mining corpus;
• implementation status;
• intended destination;
• research/custody rules;
• known source gaps;
• Phase Calculus recovery targets;
• already-extracted work that still needs to be merged;
• items requiring deeper mathematical or novelty assessment.

The TODO is deliberately exhaustive so valuable research code does not disappear simply because it was buried in an old experiment or had an unfamiliar name.

Repository philosophy

VoidKit is not intended to become a pile of thin wrappers around existing libraries. Production capabilities must be implemented by VoidKit in the Rust backend; Python wrappers around NumPy/SciPy/SymPy/NetworkX/mpmath or equivalent solver kernels are not counted as VoidKit mathematical implementations. Low-level infrastructure dependencies may support storage, FFI, memory layout, random-number generation, or similar mechanics without owning the substantive algorithm.

Standard mathematics belongs here when VoidKit provides a real implementation that is useful. Distinctive research implementations belong here when they provide something worth preserving: a derivation, algorithm, invariant, exact construction, certification path, performance characteristic, unusual composition, or other real capability.

The standard is usefulness plus mathematical custody, not novelty theater and not reinvention for its own sake.

License and citation

VoidKit is licensed under the BSD 3-Clause License. See LICENSE for the controlling terms.

If VoidKit materially contributes to research or published work, please cite the software and, when applicable, the originating research for the specific method used. GitHub and citation-aware tooling can read the preferred software citation from CITATION.cff. Method-level provenance remains important: an authored VDM or Phase Calculus method should retain the citation and research lineage associated with that method rather than being credited only as a generic utility.

Neuroca

VoidKit is developed under Neuroca, Inc., whose research program centers on neuro-cognitive architectures and the mathematical/computational systems that support them.

Repository: https://github.com/Neuroca-Inc/voidkit

---

Copyright © 2025-2026 Justin K. Lietz and Neuroca, Inc.