Spark AI NLP · research prototype · v0.2.0 · released 2026-10-05

spark-membrane

A fail-closed console that audits each synthetic 32-channel frame against pinned OES contracts. Every check runs separately, and a frame is accepted only when all of them pass. When a frame latches, the console names the engine and channel index that failed. It also shows where the engines disagree and lets a seeded explorer try one capped edit, in simulation only. Upstream repositories are pinned by commit, never copied or merged. Every threshold is an uncalibrated placeholder.

SYNTHETICUNCALIBRATED thresholds AGPL-3.0-onlyPython 3.10–3.13 · stdlib DOI 10.5281/zenodo.23175490Negative results first

Read this first: results that do not flatter OES32

  • NEGATIVEOn the locked NASA SMAP/MSL protocol, OES32 did not meet its pre-stated success criterion: it beat only EWMA on SMAP, and maxabs and CUSUM scored a higher pooled F1 (not significantly).Source: sparkainlp-x/oes-resilience@1ee533cd4360a6b1415f923c4e52cfc166b8917a README, v0.5.0 section
  • NEGATIVEOn the oes-telemetry-bench SYNTHETIC held-out set, max-abs matched OES32's detections (6/7 each) with fewer false-alarm episodes per normal hour (11.54 vs 23.08); the rates come from about 5 minutes of synthetic normal time and are highly uncertain.Source: sparkainlp-x/oes-telemetry-bench@d49472b7e12d96ec25e62ff600a94a2b5ae49209 reports/synthetic-demo-report.json
  • NEGATIVEThe multi-quantum-oes preregistered SYNTHETIC stress evaluation found no demonstrated advantage: the block score did not beat a simple max-abs baseline.Source: sparkainlp-x/multi-quantum-oes@132e0a7b2ae05c742d5b0d91be221cc0d2def106 README, Stress evaluation
  • UNRUNoes32-hls FPGA synthesis is UNRUN; its latency figure is a design target, not a measurement.Source: sparkainlp-x/oes32-hls@56a4cc29f0bfed84583fe9c21879daefdb2a116c README
  • UNRUNThe qldpc_decoder_cpp HLS kernel has no belief-propagation updates yet; its HLS synthesis and hardware-in-the-loop runs are UNRUN.Source: sparkainlp-x/qldpc_decoder_cpp@908c65dd6eb30f21ffab3348704001e4155151cd README

There is no NASA-beat claim here. The dual-engine split (explorer + auditor) is an external inspiration; the pinned repositories do not already implement it.

The seed-42 run

python3 -m spark_membrane demo --seed 42 · protocol spark-membrane-demo-v2 (SHA-256 69efc39ab63b4b11…, locked hash matches). ACCEPT requires protocol_hash ∧ residual ∧ sidecar_A ∧ sidecar_C0 ∧ sidecar_C1 ∧ sidecar_Cfold ∧ weighted; max-abs, EWMA and CUSUM are advisory.

36ACCEPT frames
4LATCH frames
7frames where engines disagree
1REPAIRED_IN_SIM (simulation only)
3LATCH_HELD

Pick a frame

LATCHACCEPT engines disagree

t = 20 · LATCH · single_channel_spike · engines disagree

Channel values at t=2032 bars, one per channel, against the reference 0. Dashed lines mark the residual tolerance ±0.08. Channels 13 are named by a failing gating check. The explorer proposal changes channel 13 by -0.1837 in simulation only.+0.08−0.08048121316202428green mark: explorer proposal at channel 13 (simulation only)

residual: firedsidecar: firedweighted: quietmax-abs: quietEWMA: firedCUSUM: fired

Two formulas, never blended. Residual R = 0.1996 vs tolerance 0.08 at index 13 → LATCH · weighted score = 0.1045 vs 0.5 → quiet.

Failing gating checks
check (engine)indexvalue vs threshold
residualoes32-residual (normative R)130.1996 > 0.08
sidecar_Aoes32_engine Profile A: coherence A130.1996 > 0.08
sidecar_C1oes32_engine Profile A: ODD symmetry C113↔290.1986 > 0.08
sidecar_Cfoldoes32_engine Profile A: FOLD8 continuity Cfold13↔140.1931 > 0.08
Advisory engines (never change the verdict)
enginescore vs thresholdstate
max-abs0.200 ≥ 0.5?quiet
EWMA3.453 ≥ 3?fired
CUSUM5.784 ≥ 5?fired

Explorer: REPAIRED_IN_SIM (evidence class SYNTHETIC). one-index delta -0.183669 at index 13 passes every gating check (|delta| <= cap 0.25); original frame kept. Proposals tried: 3.

Accepted proposal #3: channel 13, delta -0.183669; the original frame is kept.

Shield gate: EXPLORER WRITE → REFUSED (only DECODEUR or GARDIEN may write; EXPLORER proposals stay in simulation).

Engine families per frame: ● fired, · quiet; underlined columns are frames where the engines disagree. Only the gating families (residual, sidecar, weighted) decide the verdict.
t0123456789101112131415161718192021222324252627282930313233343536373839
verdict····················L···L··L········L···
residual····················●···●··●········●···
sidecar····················●···●··●········●···
weighted····································●···
max-abs····································●···
EWMA····················●···●·····●●●●··●···
CUSUM····················●···●·····●●●●··●···

EWMA and CUSUM are standardized on a separate 64-frame event-free calibration stream (calibration-seed42.jsonl, never audited) and restart after each alarm (author choice; upstream defines no reset). At t=30, 31, 32, 33 the gate ACCEPTED while advisory engines fired: the gating checks do not see that slow drift.

Fail-closed check and the 512-channel bus

Tampered protocol

protocol tolerance edited from 0.08 to 0.5 after the lock: SHA-256 0d1b61891f580816… → LATCH on protocol_hash; 6 other gating checks not evaluated; explorer LATCH_HELD (explorer disabled: protocol hash mismatch (fail-closed)).

512 channels = 16 native-32 blocks, no resampling → LATCH

0ok
1ok
2ok
3ok
4ok
5ok
6ok
7ok
8ok
9ok
10ok
11LATCH
12ok
13ok
14ok
15ok
  • block 11: LATCH — residual@ch7 (global channel 359), sidecar_A@ch7 (global channel 359), sidecar_C1@ch7 (global channel 359), sidecar_Cfold@ch6 (global channel 358); explorer REPAIRED_IN_SIM

Architecture: five planes, one new algorithm

  1. PLANE 1

    Contract spine

    oes32-residual · oes32_engine · oes32-membrane-shield

    Normative residual R, Profile A sidecar (A, C0, C1, Cfold), capability gate.

    re-implemented, tested against pins
  2. PLANE 2

    Frame bus

    oes-telemetry-bench

    Native 32-channel JSONL; 512 channels = 16 blocks of 32, no resampling.

    re-implemented parser
  3. PLANE 3

    Audit side (T=0)

    oes-resilience + baselines

    Gate: hash ∧ residual ∧ sidecar ∧ weighted. Advisory: max-abs, EWMA, CUSUM.

    conjunction logic only
  4. PLANE 4

    Explorer

    new in this repository

    Seeded one-index delta, capped by the protocol, re-audited. REPAIRED_IN_SIM or LATCH_HELD.

    the only new algorithm
  5. PLANE 5

    Evidence membrane

    measurement-trail · evidence-passport · quantum-claims-passport

    Hash-chained trail, evidence passport, claims gate that refuses overclaims.

    glue only

Frames flow 2 → 3; a LATCH from 3 goes to 4, whose proposal is re-audited by 3 and refused by the capability gate in 1; every step is chained by 5. The thresholds in plane 3 are listed with their sources in docs/PROTOCOL.md.

Evidence

What this is, and is not

A classical software simulation on generated numbers. It is not a medical device, control software or field evidence. The audit is a conjunction of independent deterministic checks, not a vote, and the two OES-32 formulas (normative residual and weighted score) are never blended.

Pinned repositories (not copied)

RepositoryCommitPlaneDOIRole here
oes32-residualb77b612contract spine10.5281/zenodo.22985520Normative OES-32 residual (ADR-001): R = max_i |y_i - x_i|, fail iff R > tolerance.
oes32_engined66025fcontract spine10.5281/zenodo.22985523Profile A sidecar: SAFE = A and C0 and C1 and Cfold (coherence, EVEN/ODD symmetry, FOLD8 continuity); LATCH = not SAFE.
oes32-membrane-shield95bb63acontract spine10.5281/zenodo.22999276Capability gate (Ed25519, v2; this commit adds the weak-key fix). spark_membrane/shield.py re-implements its capability format and role table, verifies signatures with the optional cryptography extra and ports its small-order/non-canonical key and R checks; checked against the upstream library in CI.
oes-telemetry-benchd49472bframe bus10.5281/zenodo.23175492Native 32-channel JSONL frame contract; max-abs / EWMA / CUSUM baseline definitions; synthetic held-out result (max-abs 6/7 at 11.54/h vs OES32 6/7 at 23.08/h).
oes-resilience1ee533caudit10.5281/zenodo.23071166Weighted block score 0.45*max|x| + 0.35*RMS + 0.20*mean|x| (OES32Detector); v0.5.0 SMAP/MSL result: success criterion not met.
measurement-trail7ab6ec8evidence membrane10.5281/zenodo.23067465Hash-chained JSONL record format used for the run trail; CI verifies the committed demo trail with the upstream verifier.
evidence-passporte275bb0evidence membrane10.5281/zenodo.23165143Run-manifest schema v1; CI validates docs/passport/manifest.json with the upstream validator.
quantum-claims-passport880ddc9evidence membrane10.5281/zenodo.23167801Claim-type classification with fail-closed fencing; the model for spark_membrane/claims.py.
multi-quantum-oes132e0a7linked context10.5281/zenodo.23113851Cited for its preregistered SYNTHETIC stress evaluation (no demonstrated advantage over max-abs). Its toy simulations never enter the audit.
oes32-hls56a4cc2linked context10.5281/zenodo.22985525Cited for status only: FPGA synthesis UNRUN. Its squared-difference, >= rule is a different Profile A sidecar and is not used here.
qldpc_decoder_cpp908c65dlinked context10.5281/zenodo.22985527Cited for status only: BP kernel is a scaffold; HLS synthesis and hardware runs UNRUN.
signal-loom750a806linked context10.5281/zenodo.23173453Art skin only (performance-art prototype, MIT). Linked from the page; nothing from it enters the audit.
  • evidence-passport — Static evidence passports, including the SMAP/MSL run with its criterion-not-met label.
  • quantum-claims-passport — Claim-type audit that classifies public claims against their sources.
  • spark-oes512-demo — Browser prototype of the 16 x 32 weighted block score (SYNTHETIC).
  • oes512-residual — 16 x OES-32 weighted latch reference and browser avatar (SYNTHETIC).
  • signal-loom — Art skin only: a performance-art prototype. Nothing from it enters the audit.

How to cite

Concept DOI (all versions): 10.5281/zenodo.23175490; v0.2.1 version DOI: 10.5281/zenodo.23241695; v0.2.0 version DOI: 10.5281/zenodo.23186985; v0.1.0 version DOI: 10.5281/zenodo.23175491. See CITATION.cff.

Brisson, J.-F. (2026). spark-membrane: a fail-closed console over pinned OES repositories
(SYNTHETIC research prototype, version 0.2.0) [Computer software]. Spark AI NLP.
https://doi.org/10.5281/zenodo.23175490