✨ Add Temporal Neural Solver (TNS) - Sub-microsecond Neural Network Inference - #2
Merged
Conversation
- Replaced O(log n) complexity explanation with concrete example (20 vs 1 million) - Simplified WebAssembly vs CUDA comparison with practical examples - Clarified TNS engine approach without excessive technical jargon - Made explanations more accessible while maintaining technical accuracy
- Added dedicated TNS section with quick start examples - Included links to npm package and Rust crate - Added key features highlighting sub-microsecond latency - Referenced documentation and blog posts - Positioned after main solver features for better flow
- Added temporal-neural-solver crate v0.1.2 with CLI tools - Implemented WASM package for npm/npx distribution - Created comprehensive benchmarks and validation suite - Added documentation and neural network research notes - Achieved sub-microsecond inference latency (<1µs) - Integrated Kalman filtering for temporal coherence - Dual platform support: Native Rust + WebAssembly
ruvnet
pushed a commit
that referenced
this pull request
May 19, 2026
Refuses polynomial-time solves on near-singular systems whose
diagonal-dominance margin falls below a configurable threshold —
the architectural defence against the Pi-Zero / Cognitum failure
mode where the solver burns a J/decision budget producing an
ε-quality answer the agent then discards.
New module `src/coherence.rs`:
- `coherence_score(&dyn Matrix) -> f64` — one-pass diagonal-
dominance margin in [-∞, 1]:
* 1.0 = perfectly diagonal
* (0,1) = strictly DD; Neumann series convergence guaranteed
* 0 = boundary
* <0 = not DD; iterative solvers may diverge
* -∞ = zero diagonal (degenerate row)
- `check_coherence_or_reject(&dyn Matrix, threshold)` — returns
Err(Incoherent) if score < threshold; Ok(score) otherwise.
Threshold = 0 disables the gate entirely (the default).
Wired into the public API:
- `SolverError::Incoherent { coherence, threshold }` — new
variant, `is_recoverable() = true`, severity = Low (it's a
budget refusal, not corruption), formatted error message
points the caller at ADR-001 and the opt-out.
- `SolverOptions::coherence_threshold: Precision` — defaults to
`0.0` (gate disabled) so every existing caller is wire-
compatible. Setting to `0.05` enables the recommended floor.
- lib.rs re-exports `coherence_score` and
`check_coherence_or_reject` at the crate root.
8 new unit tests cover the score function (perfect diagonal,
moderate dominance, boundary case, non-dominant, zero-diagonal)
and the gate (disabled threshold passes, enabled threshold
rejects incoherent and accepts dominant matrices).
Test count: 137 → 145 lib pass. No external API breakage —
SolverOptions still has Default + all 3 named constructors with
the new field set to 0.0.
ADR-001 roadmap: items #1 + #3 done, 4 left (#2 solve_on_change,
#4 MCP advertise, #5 joules bench, #6 contrastive adapter).
ruvnet
pushed a commit
that referenced
this pull request
May 19, 2026
The central architectural payoff of ADR-001: when a downstream system
(Cognitum reflex loop, RuView change detection, Ruflo agentic inner
loop, ruvector graph repair) delivers a *sparse* update to the RHS,
the solver pays sub-linear work proportional to ||delta|| rather than
cold-starting against the full b. Lifts steady-state cost from
`O(k_cold · nnz(A))` to `O(k_warm · nnz(A))` where k_warm ≪ k_cold
on well-conditioned DD systems with small deltas.
New module `src/incremental.rs`:
- `SparseDelta { indices, values }` — additive sparse update to a
RHS vector. `apply_to`, `as_pairs`, `nnz`, `is_empty`, length
validation, out-of-bounds rejection.
- `IncrementalSolver` extension trait blanket-impl'd for every
`SolverAlgorithm` so the entry point is available on every solver
in the crate (Neumann, optimised CG, sublinear-Neumann, …) with
no per-solver wiring needed.
- `solve_on_change(matrix, prev, delta, opts)` uses the
**residual-correction pattern**:
r = delta (= b_new − A·prev for converged prev)
dx = A⁻¹ · r (inner cold solve on a small sparse RHS)
x = prev + dx
This sidesteps the trap of feeding `initial_guess = prev` to
iterative solvers that don't honour it correctly (Neumann's
`compute_next_term` double-counts the k=0 series term, same class
of bug as the iter-2 v1.6.0 fix). Solving for the *correction*
from zero is asymptotically faster because ||r|| ≪ ||b_new||
drives Neumann's geometric convergence to fewer iters
proportional to log(||r||/||b_new||).
- `IncrementalConfig` knobs for tuning the warm-start / full-solve
crossover.
- `IncrementalSolveOp` marker type with `Complexity = Adaptive {
Linear, Linear }` and `DETAIL` documenting the sub-linear-in-
delta-norm payoff. Stable target for the future MCP `x-complexity`
schema (ADR-001 item #4).
6 unit tests pin the contract:
- SparseDelta validation: length match, out-of-bounds detection.
- Identity case: empty delta + prev_solution → same solution as
full solve.
- Tracking: incremental result on b_prev + delta matches cold
full-solve on the new RHS within solver tolerance.
- **Architectural promise**: warm-start iterations ≤ cold-start
iterations on a small delta (the headline benefit of this
roadmap item).
Test count: 145 → 151 lib pass (+6). No external API breakage —
purely additive. Existing callers keep working unchanged; the new
entry point is opt-in.
ADR-001 roadmap status: items #1 #2 #3 done. Remaining:
#4 MCP x-complexity + max_complexity_class budget arg
#5 joules_per_decision bench
#6 find_anomalous_rows contrastive adapter
ruvnet
pushed a commit
that referenced
this pull request
May 19, 2026
Cuts the minor that captures the first three roadmap items of ADR-001 (Complexity as Architecture): - item #1: ComplexityClass enum + Complexity trait - item #2: solve_on_change residual-correction - item #3: coherence gate Public API is additive — no breaking changes. SolverOptions gains one new field with default 0.0 (gate disabled), so every existing caller stays wire-compatible. Bumps: - npm sublinear-time-solver 1.6.0 → 1.7.0 - rust sublinear (crate) 0.2.0 → 0.3.0 CHANGELOG.md gets a fresh 1.7.0 section above the existing 1.6.0 entry, structured to match Keep-a-Changelog conventions. Roadmap items #4, #5, #6 stay on the cron a3644c7d backlog for the follow-up minor.
ruvnet
pushed a commit
that referenced
this pull request
May 19, 2026
ADR-001 roadmap item #6: the boundary-crossing primitive RuView / Cognitum / Ruflo's inner loops actually call. Two functions in a new module `src/contrastive.rs`: - `find_anomalous_rows(baseline, current, k) -> Vec<AnomalyRow>` Top-k rows by |current[i] - baseline[i]|, sorted desc with row index as the tie-break. `O(n log k)` via a `k`-sized min-heap (BinaryHeap with inverted Ord). Phase-1 implementation: full scan over the dense vectors. Phase-2 (tracked as TODO) drops to O(k · log n) by computing individual entries of `current` directly via the sublinear-Neumann single-entry primitive, matching what the ADR §Roadmap promised. - `find_rows_above_threshold(baseline, current, threshold)` — O(n) one-pass filter that returns ALL rows whose anomaly exceeds `threshold`. The change-driven activation primitive: an agent stays asleep until the iterator yields anything. RuView's "activate only on boundary crossing" maps directly to this. - `AnomalyRow { row, baseline, current, anomaly }` — the report shape. Comparable by row + anomaly for deterministic ordering. - `FindAnomalousRowsOp` complexity marker: `Adaptive { Linear, Linear }` today, with DETAIL documenting the planned drop to O(k · log n) in phase 2. 9 unit tests cover the API: empty inputs, k=0, k>n, top-k correctness, tie-breaks, absolute-value semantics, threshold filtering / no-match / dim-mismatch panic. Also fixes the CI failure on the previous push: src/incremental.rs:22 doc test had a type mismatch — `SparseDelta::new` returns `Result<SparseDelta>` but I passed `&result` directly to `solve_on_change`. Added `?` to unwrap the Result and `as &dyn Matrix` to make the cast explicit. The 6 unit tests in incremental had been doing the right thing; only the doc example was wrong. Test count: 151 → 160 lib pass + 11 doc tests (was 1 failing). ADR-001 roadmap: items #1 #2 #3 #6 done. Remaining: #4 MCP x-complexity advertise + budget arg, #5 joules_per_decision bench.
ruvnet
pushed a commit
that referenced
this pull request
May 19, 2026
The metric that converts "this is edge-deployable" from vibes to a
falsifiable number. ADR-001 §SOTA criterion required this before the
package can be called complete. New file
`examples/joules_per_decision.rs`:
- `PowerCounter` trait with two impls:
* RaplCounter: /sys/class/powercap/intel-rapl:0/energy_uj
— works on Intel and AMD Zen 2+ via the
compatible interface, microjoule resolution.
* TimeOnlyCounter: wall-clock fallback when RAPL is unreadable
(sandbox, macOS, locked-down host). Reports
energy as `(not measured)`, prints timing
only.
- `pick_counter()` tries the impls in order and never panics.
- Two workloads:
* OptimizedConjugateGradientSolver (n configurable, default 256)
* NeumannSolver
plus a 100-iter warm-up so the first sample doesn't capture cold
cache + JIT.
- Report struct prints joules, average watts, µJ/solve, µs/solve
when RAPL works; just µs/solve when it doesn't.
Local run on the dev host (RAPL not granted to user; fell back to
time-only):
OptimizedConjugateGradientSolver, n=256: 0.77 µs / solve
NeumannSolver, n=256: 47.98 µs / solve
That's a 62× CG-over-Neumann ratio, consistent with the BENCHMARK.md
baselines from the v1.6.0 release. With RAPL granted (root or
chmod a+r), the same workload reports actual joules and average
watts.
Run with:
cargo run --release --example joules_per_decision
cargo run --release --example joules_per_decision -- --n 1024 --iters 5000
Phase-2 plan (in the source as a comment):
- Integrate into the CI bench-smoke job once a stable per-job
power counter exists (currently GitHub Actions doesn't expose
one).
- Add hwmon backend for the Pi Zero 2W path.
ADR-001 roadmap: items #1 #2 #3 #5 #6 done. Only #4 (MCP
x-complexity schema + max_complexity_class budget) remains.
3 tasks
ruvnet
added a commit
that referenced
this pull request
May 19, 2026
feat(adr-001 #2): solve_on_change_sublinear — SubLinear delta-solve
ruvnet
pushed a commit
that referenced
this pull request
Jul 5, 2026
Completes the verifiable structural backlog. src/plateau.mjs is a pure, deterministic detector: a plateau is declared only when ALL three hold over a rolling window -- median per-generation improvement < epsilon, promotion rate < max, and candidate-score variance shrinking. It emits a classification (local-optimum / noisy-benchmark / still-improving / inconclusive), separating a real local optimum from noise or optimizer failure without intuition. run-plateau.mjs builds a 6-generation history with diminishing returns, gates every candidate with the real ADR-076 gate, derives per-generation stats (bestDelta, promotion rate, score variance) from the real decisions, and applies the detector (final verdict + per-prefix trace showing WHEN it fires). On the demo history it declares plateau=true (local-optimum) first at generation 4. verify-plateau.mjs re-gates every sealed candidate, rebuilds the history, and recomputes the detector -- asserting the history and verdict reproduce bit-for-bit. Deterministic; the plateau signal is verifiable, not a claim. Outcomes remain synthetic and are shaped to diminish so a plateau forms; the real/synthetic boundary is unchanged. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_011cHoWPXP5UHwVaNYwjhvjn
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
This PR adds the complete Temporal Neural Solver (TNS) implementation, achieving sub-microsecond neural network inference through mathematical optimization and temporal coherence.
What's Included
🚀 Core Implementation
tnscommand) with demo, benchmark, validate commands⚡ Performance Achievements
📦 Package Distribution
cargo install temporal-neural-solvernpx temporal-neural-solver demo📁 Files Added
/tns-engine/temporal-neural-solver/- Main Rust implementation/temporal-neural-solver-wasm/- WASM package source/docs/neural-networks/- Research and documentation🔬 Validation
Testing
Links