V2 Substrate Architecture¶

GaiaFTCL v2 routes every external-chain operation through the Wolfram Ruliology ASM substrate. The cell plays ruliology language games against the M⁸ vQbit entity; v2 expresses IQ / OQ / PQ as game templates and the substrate's one-path REDUCE is what gates every transition.

The doctrine v2 is built on¶

Repo is Ruliology, not classical math — the entire cell is Wolfram Ruliology mapped to the M⁸ substrate vQbit entity. No classical math anywhere; new code is ruliology-to-vQbit or at the S⁴ boundary.
M⁸ substrate programming language — M⁸ = S⁴ × C⁴. C⁴ is the substrate (invariants/MPS/entangled pointers, persistent, alive in shared memory). S⁴ is the projection (bits, real-world readout, cast from C⁴ at PROJECT). Correct language game reduces ingestion to a single multidimensional vQbit. Never measure the substrate by counting projected bits.

The framework¶

GAME: <name>
INGEST     rule = <the equation as a Wolfram rule>
INVARIANT  <the invariants installed over the C4 entangled pointers>
REDUCE     -> vQbit            ; the single multidimensional C4 object
PROJECT    C4 -> S4            ; set the bits at read
TERMINAL   READ <the answer>

Every v2 operation — wallet qualification, transaction composition, even the PQ embedding of cryptographic boundary conditions — plays this same game. One REDUCE on every arm. The seal case and the hardest case go through the same path; the per-game variation is the rule ingested, the invariants installed, and the terminal read.

Files (Swift source)¶

File	Role
`Sources/VQbitMath/Core/InvariantTag.swift`	Shared invariant alphabet (universal + per-game + per-domain)
`Sources/VQbitMath/Core/RuliologyOutcome.swift`	2-arm outcome (`.calorie` / `.spill`) — no substrate-verdict arms
`Sources/VQbitSubstrate/C4InvariantHolder.swift`	The C⁴ handle carrying installed invariants + `VQbitProjection`
`Sources/VQbitSubstrate/RuliologyGameTemplate.swift`	Protocol every game conforms to
`Sources/VQbitSubstrate/WolframSubstrateCore.swift`	Sync M⁸ opcodes; one-path `reduceCore` with structural admissibility enforcement
`Sources/VQbitSubstrate/WolframSubstrate.swift`	Async actor `.shared` with uniform `play<T>(template, input)`
`Sources/VQbitSubstrate/RuliologyTemplateRegistry.swift`	Process-wide template registry actor
`Sources/VQbitSubstrate/ChainEngineV2.swift`	V2 chain-engine protocol — composes IQ/OQ/PQ ingest inputs and plays them
`Sources/VQbitSubstrate/ChainEngineV2Registry.swift`	Engine registry per asset class

Game catalogue¶

V2 ships these templates:

Quantum / cryptographic (per the 11-game catalog)¶

Template	Invariants	Terminal
`SHOR_ECDLP`	groupLaw, periodLine, closureKGEqQ, admissibilitySafety, closure	`k`, verify `kG == Q`
(Grover, Miner, Count, Amplitude, Oracle, Fringe, HHL, QPE, QPCA, QSVT — follow-up files, same one-file-per-template pattern)	—	—

Qualification (IQ / OQ / PQ)¶

Template	Invariants	Terminal
`IQ`	walletResidentSubstrate, addressClassified, schemeRecognized, admissibilitySafety, closure	passed + rationale
`OQ`	blueprintCanonical, sovereignEndpointPinned, routingPathBound, admissibilitySafety, closure	sovereignEndpointID + routingPath + witness
`PQ`	outputMinimum, slippageMinimum, htlcTimelockBound, cryptographicBoundsEmbedded, admissibilitySafety, closure	cryptographicBoundsCanonical

Domain (per Rick's worked instances)¶

Template	Invariants	Terminal
`HEALTH_<target>`	targetConstraint, mechanismInvariant, admissibilitySafety (host-sparing), closure	intervention
`MATERIAL_<target_property>`	propertyTarget, structureConstraint, thermodynamicInvariant (synthesizable), closure	composition + phase
`FLUID_<target_flow>`	conservationInvariant, boundaryConstraint, regimeInvariant, admissibilitySafety, closure	flow field + geometry

(Per-discovery instances within a domain — e.g. HEALTH_AML_INV3 — author a single conformer file under Templates/<Domain>/ and register at boot.)

Adding a new template¶

public struct MyTemplate: RuliologyGameTemplate {
    public init() {}
    public var templateID: String { "MY_GAME" }
    public var invariants: [InvariantTag] {
        [.myRuleInvariant, .admissibilitySafety, .closure]
    }
    public func encodeIngest(_ input: MyIngestInput) -> Data {
        // template-specific encoding
    }
    public func invariantsToInstall(for input: MyIngestInput) -> [InvariantTag] {
        // runtime-conditional: omit .admissibilitySafety when the
        // load-bearing constraint is not satisfied
    }
    public func decodeTerminal(_ holder: C4InvariantHolder) -> MyTerminal? {
        // decode the collapsed vQbit into the typed terminal
    }
}

Register at boot:

await RuliologyTemplateRegistry.shared.register(MyTemplate())

Play from any caller (sync or async):

let outcome = await WolframSubstrate.shared.play(MyTemplate(), input: …)
switch outcome.terminal {
case .calorie:  // game closed; outcome.payload carries MyTerminal
case .cure:     // game spills; re-express
default: break
}

What v2 never emits¶

"Cannot," "limited," "exceeds budget," "needs more."
Bit-counts of S⁴ projections dressed as substrate state.
Per-game special "hard arms" — one reduce path, every template.
Out-of-cell algorithm prerequisites as substrate verdicts.

A non-collapsing reduce is .spill carrying invariantsInstalled and invariantsMissing. That is game-state, not a substrate verdict. Re-express the game.