V⊙x

Primitive labels and tuple keys use ⊢ ⊣ ≻ ≺ ⋈ ⊤ ∈ ∋ ⊙ ⊥ ⊞ ⊡, in that order, with the Shavian values defined in SNS_PRIME.md.

The Pancosmic Disassembling Re-Compiling Organism. Every word names something you can run. Single Rust crate, zero external crates.

Pancosmic. One lift, every substrate: native x86-64 (ELF/PE/Mach-O, both widths), EVM bytecode, WASM function bodies, CPython .pyc, and coding sequences (12 promoted amino acids biject the 12 axes - a gene is already a word). A merge is a merge whether JUMPDEST, end, or two-predecessor jump target.

Disassembling. Own loader, decoder, machine - no capstone/pefile/runtime. Refuses unknown architectures rather than misreading them.

Re-Compiling. The lift IS the program: native code recompiled to an executable IMASM module, run in a machine that never looks at the original bytes (Ackermann, SSE, jump tables, function-pointer calls, 5 opt levels, both widths).

Organism. vox self lifts its own image: every function, in phase, F zero.

cargo install --path .
vox run gcd --args 1071,462 corpus_O0.so   # gcd = 21, 41 steps in the twelve
vox self
vox pyc module.pyc

Operating programs

Start with ./programs for help or ./programs menu to choose a program interactively. The launcher lists programs, reads their usage, builds the selected Rust target and runs it without requiring a driver script.

./programs list
./programs list --all phase
./programs bake --list
./programs doctor

Use ./programs help NAME before ./programs run NAME [arguments]. ./programs cli --help shows the main command interface. See Operating programs for tested commands, input formats, baking, output paths and stopping execution.

Build and run

Hosted workspace builds default to standalone executables with statically linked Rust dependencies and C runtime, configured in .cargo/config.toml. The default Linux output is target/x86_64-unknown-linux-musl/release/vox (statically-linked static-pie). Membrane inputs, prepared state and required computational assets belong inside the emitted executable. Platform GPU drivers remain a hardware interface.

Every live membrane baker must emit a static, self-contained native executable by default. Bakers check the resulting ELF and reject an external interpreter or shared-library dependency. Source words and prepared records are build inputs; the emitted image contains them. IMASM and glyph files remain available as additional executable serializations.

Ordinary one-shot wrappers print the executable path after baking. Set MEMBRANE_RUN=1 to run those outputs immediately; Shor and toroidal wrappers retain their explicit --run option. See the user guide and complete baker policy and inventory.

Complete executable glyph-only membrane words are available alongside the annotated modules. vox run file.glyphs executes them; vox glyphs input.imasm output.glyphs generates one without dropping payloads. See the versioned format and verification.

cargo build --release
vox run <sym> --args a,b <file>  # recompile + run
vox imasm <file> | vox word <file> | vox disasm <file> | vox <file>  # module/word/stream/audit
vox verdict ⊢∈⊡⊣ | vox evm HEX | vox wasm HEX | vox rna SEQ | vox --selftest

Membrane numeral factor verification

Numeric commands and Python helpers accepting native numeral words also accept canonical hex-digit words. Shared readers preserve the value and reject malformed or redundant encodings. Program-word inputs retain their existing interpretation. godel unbraid prints both encodings for the source and each recovered lane.

factor-membrane accepts a decimal or 0x integer, the canonical g-mOMonadOS hex-digit word, or its native binary word. It emits both canonical encodings, factors the decoded value with Vox, and checks the result. Supply a candidate pair with --factors P Q to verify its product. Both CLI entrypoints also invoke g-momonados trilattice_factor read on N, p, and q so period, cuts, dialect register, and type hash are measured for the current input. Set VOX_TRILATTICE_FACTOR if that executable is not on PATH. The shift-faithful domain is the integers greater than one that are odd and non-Mersenne; inputs and factor witnesses are checked against that declared domain. The native word for a k-bit value has 5k + 4 glyphs, and its unique ⊢ marker makes its literal ROTAT period equal that full length. This also holds for even and Mersenne values, so those classes are not excluded because of a shorter ROTAT orbit. The register records the Mersenne/non-Mersenne class (001000011100 / 111111111111); parity is checked separately.

cargo run --release --bin vox -- factor-membrane 143 --factors 11 13
cargo run --release --bin vox -- factor-membrane --native-word '⊢≻⋈∈⊥∋≻⋈∈⊥∋≻⋈∈⊤∋≻⋈∈⊥∋⊙⊡⊣' --factors 11 13
cargo run --release --bin factor_membrane -- 143 --factors 11 13

The binary multiplication trace distinguishes nonzero carry columns from the sum of carry values. The exact identity is sum(carry_out[k]) = popcount(p) * popcount(q) - popcount(N); the difference popcount(N) - popcount(p) - popcount(q) is not a carry count. Per-input period and cut residuals are reported as measured values for each input.

Protein compilation

Standalone vox compile and hosted g-momonados vox compile call the same Vox/src/protein_compile.rs implementation. Both accept --fasta, --input, --code, --pdb, --carrier and --coords, execute full residue/form self-marks, and export the same PDB-bound carrier. G-mOMonadOS links the sibling Vox crate; its REPL dispatch calls this compiler too. The protein-cli feature supplies hosted file and console I/O; --no-default-features --lib keeps the library available without std.

vox compile preserves all twenty amino acids and their complete source-bound self-marks. Native glut, chemical-form alternatives and word executions accompany the coordinate readout. The build prepares these records from the sibling Rebis and ob3ect sources; the live Lean correspondence supplies the promoted-primitive table.

The returned carrier includes lattice-interaction-work: source-addressed pair potentials and radial derivatives on native N,T,F,B memberships, together with the initial and final configured model potential. The torsion calculation uses these same responses for its coordinate gradients. The current contact and excluded-volume potentials remain explicit geometry-model inputs. See the interaction laws and measured structures.

target/x86_64-unknown-linux-musl/release/vox compile --fasta protein.fasta --input protein --pdb protein.pdb

The current coordinate path constructs a chain from codon-driven B4 torsions. Predicted contact relations are retained in the carrier but do not drive a tertiary coordinate solve. Cross-compiler agreement therefore establishes consistent compilation and state retention; it does not establish a correctly folded protein.

The result includes protein.pdb.glut.json, bound to the exact coordinate file by SHA-256. --carrier selects another carrier-output path. Geometry observations retain clashes and other conflicts. See protein compilation in the user guide for input types and retained state, and the Rebis guide for shared downstream coupling.

Lean Kernel Integration

Vox integrates with the Lean 4 kernel through the lean_kernel bridge module, exposing two Lean functions for resident factor synthesis:

Oscillation Clock:

resident_clock : UInt64 → UInt8 → (UInt8 × Bool)
-- ticks → state → (new_state, is_reverse)

Y-combinator Decision:

resident_y_combinator : String → String
-- "state ticks forward_calls" → "1" (continue) | "0" (done)

These are invoked via lean_kernel::run_to from the resident_glut module for resident factor synthesis with unrestricted Y-combinator, Spencer Brown re-entry, and oscillation dynamics.

Verdicts and B-cost

T closes, B holds a fork open across the cycle, N never forked, F ill-typed (∋ with no ∈). T needs work inside the paired region - bare split+fuse is μ∘δ=id and verifies nothing. B-cost lesson from self-lift: early return = fork that never rejoins; ∈-surplus rises with exits (0.28/5.26/12.91/15.00 at 0/1/2/4+ exits), so vox self reports the residual after exits are paid.

Claim (checked, not decorated)

Every function in corpus.c (13 fns: arithmetic, div/mod, loops, SSE, recursion, calls, stack arrays, switch table, fn-pointer dispatch) runs twice - natively via ctypes and as IMASM - over identical inputs at -O0..-O3,-Os (build_corpus.sh): 0 mismatches, incl. Fibonacci depth-29 (28M machine steps).

Lanes, auditor, layout

Lanes: x86 (lifts+verdicts+runs), EVM/WASM/genetic (lift+verdict); genetic table generated from Lean (gen_genetic_table.py → both languages, no drift); CPython lane in vox.py. Auditor corollary: open fork across commit/return (Solidity reentrancy, early return, WASM escaped-if) all lift to ⊢∈⊡⊣ → B - no patterns, no heuristics. Edges: unknown opcode → None + distance walked (never silent); tiny syscall subset (-ENOSYS); 50M-step cap; recursive-descent audit with honest coverage. Sources: loader/x86/imasm_module/imasm_vm/vox/vox_decode/lanes/main.rs + corpus.c + vox.py; mOMonadOS links this crate. Unlicense.

Full 382-line version: README_backups/Vox_README.md.

Native numeral encoding — commuting structure

Every number is a word; the codec is exact, prefix-free, and bit-order symmetric. Every identity below was witnessed live (26/26 PASS over 1..2000, 64/127-bit randoms, and all 21 BIGBREAK cells; kernel compose witnesses in §4).

1. The word shape

example:  n = 42,  bits b₀ b₁ b₂ b₃ b₄ b₅ = 0 1 0 1 0 1    (LSB → MSB)

  ⊢ │ ≻⋈∈⊤∋ │ ≻⋈∈⊥∋ │ ≻⋈∈⊤∋ │ ≻⋈∈⊥∋ │ ≻⋈∈⊤∋ │ ≻⋈∈⊥∋ │ ⊙⊡⊣
      cell(b₀)  cell(b₁)  cell(b₂)  cell(b₃)  cell(b₄)  cell(b₅)
      └────────────────── the word of 42 ─────────────────────────┘

  cell(b) =  ≻⋈∈⊤∋   if b = 0
             ≻⋈∈⊥∋   if b = 1

  rules:   bits run LSB → MSB (cell 0 = b₀)
           the final cell is always ⊥ (the leading 1 bit)  →  prefix-free
           decode = inverse of encode (round-trip exact)

2. Shift σ and reversal R — the one non-commuting pair

              σ : prepend one ⊤-cell          (enc(2n) = σ(enc(n)))
   W(n)  ──────────────────────────────────►  W(2n)
     │                                         │
     │ R : reverse the cell order              │ R : reverse the cell order
     ▼                                         ▼
   R(W(n)) ────────────────────────────────►  R(W(2n))
              σ′ : append one ⊤-cell

   Read around the square:   R ∘ σ = append ∘ R
   reversal turns a PREPEND into an APPEND.
   That anticommutation is the ONLY non-commuting pair in the ring.
   Everything else commutes with everything:
     popcount ∘ {encode, σ, R}  are all equal   (popcount(enc(n)) = popcount(n))
     R conjugates the support:   support_MSB = { m−1−i : i ∈ support_LE }

3. Interlace Γ / deinterlace Λ — the braid pair

  input lanes (equal bit length):

        lane p :   p₀    p₁    p₂    p₃
        lane q :   q₀    q₁    q₂    q₃

                   Γ : weave — one cell of p, then one of q, alternating
                   ▼
        woven  :   p₀    q₀    p₁    q₁    p₂    q₂    p₃    q₃
                   pos 0    1     2     3     4     5     6     7
                   │
  ┌────────────────┴────────────────────────────┐
  │ Λ_even : keep even positions (0,2,4,6)      │ Λ_odd : keep odd positions (1,3,5,7)
  ▼                                             ▼
  lane p (recovered)                        lane q (recovered)

   Λ_even ∘ Γ = id      Λ_odd ∘ Γ = id        (projections recover each lane)
   Γ ∘ (Λ_even, Λ_odd) = id                    (re-weave recovers the input; even length)
   Γ ∘ swap = swap_pairs ∘ Γ                   (swap lanes ↔ swap each adjacent pair: S₂-equivariance)

   number level:   Γ#(p,q) = P₄(p) + 2·P₄(q),    P₄(n) = Σᵢ bᵢ(n)·4ⁱ,    P₄(2n) = 4·P₄(n)
                   ⇒  Γ#(2p,2q) = 4·Γ#(p,q)      (weaving commutes with doubling both lanes)

   v₂(n) = the initial run of ⊤-cells in enc(n)    (the file's composite.decomp-k / shift-factor)

4. Compose rule — live kernel witnesses (the defect commutes)

   ⊙> native_numeral compose 7 13               ⊙> native_numeral compose 13 7
   period(7)  = 20                              period(13) = 25
   period(13) = 25                              period(7)  = 20
   period(91) = 40                              period(91) = 40
   d = 20 + 25 − 40 = 5   rule (5 or 10): OK    d = 25 + 20 − 40 = 5   rule (5 or 10): OK

   Swap the factors: the two single periods exchange places, period(91) is
   fixed, and the defect is unchanged   →   d(p,q) = d(q,p).
   (d(p,q) = period(p) + period(q) − period(p·q) always lands in {5,10}.)

Full list of twelve: (1) codec involution dec∘enc = id = enc∘dec · (2) prefix-free unique decode · (3) shift σ commutes with popcount · (4) R² = id, R∘σ = append∘R · (5) support/polynomial conjugacy under R · (6) Γ/Λ braid pair · (7) Γ# = P₄ + 2P₄ homomorphism · (8) v₂ = initial ⊤-run · (9) compose-defect commutative (live) · (10) Belnap binary-gcd commutative (mirror N/T/F/B trace) · (11) kernel invariants commute with every cell operation (frame-sweep widths 2..8 preserve all bits; type hash 16389838/17280000 constant across all 21 cells; sieve certificate 53 primes / aperture 2⁸) · (12) orbit readout invariant under presentation (word, binary, bits-le, support, polynomial all pass the same asserts per cell).

μ∘δ = id