Private artifact / Advanced private research
Hyperplex.TDA
A real-time topological analysis engine for dynamic swarms. It turns a moving point cloud into connectivity signals — components, bottlenecks, holes — under a 16.6 ms frame budget, where most topology algorithms politely decline to participate.
Current public status
Hyperplex.TDA is not a public product and not an open-source release. It is advanced private research being shaped into a defensible engineering artifact. The public page exists to describe the problem, architecture, and validation discipline without prematurely publishing source or packaging promises.
Research state
Advanced work in progress
The architecture, compute tiers, replay contract, and validation strategy are developed enough to discuss publicly.
Source status
Private
Source, datasets, snapshots, profiler captures, and benchmark traces are not published while the product direction is still undecided.
Artifact status
No public package yet
There is no downloadable build, license promise, API surface, or repository release at this stage.
Evidence status
Method first, numbers later
This page documents the engineering approach. Numerical claims will wait for releasable captures and reproducible evidence.
The question
In an autonomous swarm, a pretty formation does not imply a robust network. A fleet can look coordinated while sitting one dropped link away from splitting into two groups that can no longer talk to each other. The structure that matters — who is connected to whom, where the bottlenecks are, which loops are holding — is topological, and it is invisible to the eye and to simple distance checks.
Topological data analysis answers exactly these questions, and it is a mature field: persistent homology, Vietoris-Rips complexes, connectivity analysis. It is also built, almost entirely, for offline use. The question Hyperplex.TDA investigates is narrow and awkward: can the useful parts of TDA be restructured, approximated, and scheduled so they produce honest topological signals inside a frame budget a game engine will accept — while the swarm keeps moving?
The approach: budget topology like level-of-detail
The core decision is to stop treating topology as one expensive computation and treat it as a tiered, budgeted one. Not every metric needs to run every frame. Cheap, high-value signals run hot; expensive ones run slower or move offline entirely. Full persistent homology is not attempted in real time — it lives in the offline tier, where it belongs.
| Tier | Rate | Role |
|---|---|---|
| Tier A | 30–120 Hz | Real-time health. β₀ connected components via union-find (split/merge detection) and λ₂, the Fiedler value, for algebraic connectivity, computed with a fixed iteration budget. |
| Tier B | 10–20 Hz | Budgeted features. A β₁ proxy: fundamental cycles from a spanning forest, bounded per component, shown only after they stay stable for several frames (hysteresis to stop flicker). |
| Tier C | On demand | Offline validation. High-fidelity analysis, including full persistent homology, in a .NET 10 CLI. Benchmarked against reference implementations on known datasets. |
The governing rule is blunt: stale topology is preferable to dropped frames. If the budget is threatened, the expensive tier is skipped and the visualization reuses its last stable result, with the staleness tracked and shown rather than hidden. A signal that is 80 ms old is useful. A 30 ms frame is not.
The architecture
The runtime is Unity 6.3 with Burst and the Jobs system. The hot paths — spatial hashing, neighbor-graph construction, the union-find pass — are data-oriented: structure-of-arrays layout, bounded-degree graphs packed into contiguous arrays, and no managed allocation inside the per-frame loop. The graph is built with a flexible container that tolerates density spikes, then compacted and distance-sorted into a cache-friendly, deterministic iteration form.
Visualization is GPU-first. Component colors and active cycles are written to compute buffers and drawn with indirect instancing, so showing ten thousand agents and their topology does not mean instantiating ten thousand objects. The whole runtime is a strict multi-rate pipeline with a per-subsystem budget that has to add up to a frame:
- Simulation and spatial hashing: the critical base, capped tightly.
- Graph build (kNN / radius): degraded by reducing the neighbour cap before it overruns.
- Tier A metrics: fixed-iteration, capped; λ₂ reduces its iteration count under pressure.
- Tier B cycles: best-effort and double-buffered; skipped rather than allowed to stall the main thread.
- Render: the other protected subsystem, preserved alongside simulation.
The offline tier is a separate .NET 10 CLI: System.Text.Json source generation, an AVX2 baseline with optional wider SIMD paths and a scalar fallback for correctness, and Native AOT as a first-class target. It is where the high-fidelity, reproducible analysis runs, cleanly separated from the real-time runtime that feeds it snapshots.
Determinism and replay
A real-time system you cannot reproduce is a system you cannot debug. Hyperplex.TDA is
built around a replay contract: a seeded simulation, stable scheduling, and versioned
snapshots (*.hpx.json) that capture everything an analysis depends on — seed,
tick index, timestep mode, budgets and caps, coordinate policy, and an integrity hash over
a canonicalized form of the data.
Determinism is defined in honest levels rather than promised absolutely. The offline CLI is the strict tier: the same snapshot, CLI version, and flags produce bit-identical canonical output, with float-derived metrics bounded by documented tolerances. The Unity runtime targets stable behaviour for a given seed but accepts float drift across hardware, because cross-platform bitwise float determinism is named as a non-goal instead of being quietly assumed. Each metric carries its own tolerance: component counts are exact; the spectral value is held to roughly ±1e-4; the cycle proxy to ±1, because it is budgeted and order-sensitive.
Quality assurance
The project is built for defensible claims rather than demo vibes, which means the test system is part of the design, not an afterthought. It rests on golden datasets — known graphs and synthetic topologies (a circle, two merging circles, a 3D torus, a swarm-split event) with expected component counts, spectral values, and cycle ranges recorded as machine-readable vectors.
Three gates run in CI. Deterministic regression: a snapshot's canonical hash and the CLI's metrics must match the recorded expectations, exactly for integers and within tolerance for floats. Performance regression: real-time kernels must stay under their budget caps on a defined baseline, or emit the expected skip counters under deliberate overload. Cross-platform validation: the same metrics must land inside their tolerance envelope on Windows and Linux. Updating a golden is allowed but deliberately rare, and requires a justified pull request that bumps the schema and the changelog together.
What it is, and what is still being measured
Hyperplex.TDA is advanced work in progress, not a released product. There is no public package, source repository, license promise, API guarantee, dataset, or downloadable demo. The architecture, the budget contracts, the determinism policy, and the test methodology described here are the public part of the work. The private part remains the implementation, the validation data, and the measured evidence.
So the claim on this page is architectural, not numerical. The frame budget is the target the system is built to hold and the gates are written to enforce; the measured traces that prove it will be published only if and when there is a public release path that can carry them responsibly. Invented benchmark numbers would be easy and worthless. The interesting result is whether the discipline holds at scale, and that is the work.