Skip to content

STAGE2-CUBE-ABSORPTION.md

Latest commit

 

History

History
104 lines (88 loc) · 6.99 KB

STAGE2-CUBE-ABSORPTION.md

File metadata and controls

104 lines (88 loc) · 6.99 KB
Raw

Stage 2 — cube absorption (SpanishBCBL → prism arm)

Frame: the fabric absorbs any data by representing it across the 43+ addressable layers × the 60D BEHCS-1024 tuple space — and the addressed representation is the cube. Reduction is represent + address + derived-digest, with the raw preserved once by sha256 (referenced, not reconstructed). This is not lossless magic and not a Shannon violation; it is addressing.

Canonical contract = Rust on the metal kernel (not Node). host8/qprism_cube_host8.rs is the authoritative Host-8 cube/selector contract ([u8;8] handles, no serde/JSON/Node), built + tested on WSL Ubuntu rustc (4/4). The Python qprism/cube_absorb.py is the sim/harness reference only. Both agree byte-for-byte: node PK handle8 = FNV-1a-64(node_id) = 5bd9437e2a3fe005 (Rust == Python == tools/graphify/graphify.py).

Bilateral-converged handles + selector (acer ↔ liris, GitHub-mediated):

  • handle8 = FNV-1a-64(node_id) — graphify node PK (both colonies; liris switches from her earlier fold_host8_source_tuple to this for true node-identity parity).
  • source8 / tuple8 = sha256(...)[..8] — content/provenance handles (adopted from liris).
  • selector = graphify-V3 ASOLARIA-GRAPHIFY-V3-HYPERBEHCS-60D, the canonical 11 selector_axis:*
    • selector_constraint:hyperbehcs-selector-router-60d (the live :4790 schema).

The carrier is a json=0 HBP tuple row, not JSON (JSON is cold-debug only).

raw M/EEG (D:, referenced by sha256)
   → derived feature window            (MNE / Brain2Qwerty `studies`, in WSL/Ubuntu on D:)
   → canonical 3200-byte QUANT TUPLE   (turbo 1024·int8 + signs 128 + zeta 1024 + hist 256·u32)
   → kernel-native cube node           (handle8 Host-8 PK + glyph + 60D selector envelope; raw_in_repo=0)
   → json=0 HBP tuple row              (CubeSource → prism arm → blinded harness)

Canonical format (aligned to the shipped engine + graphify)

TUPLE_BYTES = 3200, matching D:/asolaria-combined-quant-2026-06-15/combined-quant-engine.mjs (turbo 1024 + signs 128 + zeta 1024 + hist 1024) and Liris's qprism-quant-chunk (3200 B, D=1024). turbo/signs/hist faithful; per-lane zeta is a layout-compatible stand-in pending byte-parity with the canonical zetaClassify — a bilateral verify step.

Selector envelope (graphify sel:*, verified byte-identical handle8/glyph): room(D37) · handle8(D16) · to_pid60-tuple · PortLabel(D13) · domain1/8 · tier1/6 · executor(D1) · signgate(D11) · runtime/E-axis(D12).

Example kernel-native cube row (json=0, qprism.cube_absorb.absorb_window, synthetic fixture):

QPRISMCUBE|handle8=5bd9437e2a3fe005|glyph=gly-stcI|node=qprism/cube/bcbl190626/SpanishBCBL/S5/1/12.5/5d8b1027…
|dataset=bcbl190626/SpanishBCBL|license=CC-BY-NC-4.0|subject=S5|session=1|modality=MEG
|win_start_s=12.5|win_dur_s=0.5|n_samples=25|feat_sha16=5d8b102753b7fcfb|tuple_sha16=969d2b5e47e97e3e
|tuple_bytes=3200|source_sha256=…referenced-on-D|sel_room=qprism/SpanishBCBL/S5|sel_topid=HG1024:QPRISM:stcI
|sel_portlabel=qprism.cube|sel_domain=vector|sel_tier=RESTRICTED|sel_executor=host8.quant.cube-absorb
|sel_signgate=UNSIGNED|sel_runtime=staged|raw_in_repo=0|derived_only=1|json=0

Metal-kernel note (honest): this delivers the kernel-native format — a cube BINDS to the Rust 8-byte Host-8 metal kernel by its handle8 PK. Actually executing the quant ON the metal kernel (vs the Python reference here) is the operator-gated migration, not fired: sel_runtime=staged, sel_signgate=UNSIGNED, E=0.

Phases

  • Phase 1 — cube-absorb adapter (DONE, this branch): qprism/cube_absorb.py + CubeSource → prism arm; 5 tests. Runs on the synthetic MEG fixture today; identical path for real data.
  • Phase 2 — events-first ingestion (doc, no download): in WSL/Ubuntu on D: pip install mne neuralset neuralfetch + clone brain2qwerty so import studies resolves, then 
    import studies                                   # registers Pinet2024Meg/Eeg
from neuralset.events import Study
study = Study(name="Pinet2024Meg", path="D:/qprism-data/SpanishBCBL")
study.download(); events = study.build()         # sentence/word/keystroke timings
    Epoch MEG around keystroke/word events → feature windows → absorb_window(...) → cube chunks.
  • Phase 3 — real slice (gated): ONE participant end-to-end; the 280 GB download is deferred to explicit operator go. Only derived cube chunks + receipts leave D:.
  • Phase 4 — bilateral converge: acer 3200-byte cube ↔ Liris qprism-quant-chunk byte-parity; merge the stronger zeta/schema. GitHub is the mediator.

Space is expandable per slice (Brown-Hilbert digital expansion)

Grounded in Brown & Fedotov, Integration and Refinement of Digital Physics (Dec 2024): a frame-based discrete universe of spacetime pixels, evolving by metatags; and the Metatagging-data-for-a-Quantum-universe vectorspace doc (temporal/interaction-driven expansion).

A cube's address is not a fixed point — it is a 1024-ary Brown-Hilbert prefix (depth 6 = 2⁶⁰, the 60D ceiling). Space expands per slice (frame): between any two addresses, a new pid-addressable point can be injected one slice deeper (bh_inject_between → midpoint at depth+1; there is always room because deepening multiplies the gap by 1024). So as space/time grows to the next slice, points slot in between existing ones. The row carries: space_expandable=1 | frame=N | bh_depth=6 | bh_prefix=d0.d1…d5 | inject_between=bh_digital_expansion.

Honest tag: this is addressing capacity — the address form is expandable and points are injectable; it does not materialize infinite points. Materializing an expanded slice is operator-gated (E=0). (pixels_first traces to the paper's spacetime-pixels; the frontend only projects that discrete pixel substrate.)

Round-trip proof (comb coherence, lossless transcode)

The claim "losslessly transcodable across levels" is proven on our own artifact: transcode_256_to_1024 separates a cube's 3200-byte tuple into 2,560 base-1024 glyph "lines" (25,600 bits ÷ 10; the "4 symbols ⇄ 5 bytes" packing), and transcode_1024_to_256 recombines them — byte-identical, sha256-identical, 0 loss (Rust roundtrip_lossless_transcode_comb_coherence + Python roundtrip_proof, and Rust==Python symbol-identical). This is the comb: separate → recombine, coherent — a bijection between representation levels, NOT compression below entropy.

Gates

  • No raw M/EEG in git. raw_in_repo=0, derived_only=1 on every chunk; raw stays on D:, sha-referenced.
  • License: CC-BY-NC-4.0 — research/non-commercial only.
  • Claims gate: real data does not bypass the honest-null. A cube-driven CubeSource wins in the harness only if the neural signal genuinely correlates with better control (see docs/CLAIMS-GATE.md).
  • No third-party personal data (no subject identities beyond de-identified IDs; no collaborator contacts).