From 8d38d509d43251d27d87cc2c9b5ce088aa6dd604 Mon Sep 17 00:00:00 2001 From: Julian Sanders Date: Tue, 30 Jun 2026 15:46:49 -0700 Subject: [PATCH 1/4] docs: refresh v0.3.19 SFCS docs index --- docs/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/README.md b/docs/README.md index 6b9e64b..b8107aa 100644 --- a/docs/README.md +++ b/docs/README.md @@ -12,7 +12,7 @@ This index is the authoritative map for Power House v0.3.19 documentation. | [Memory Capsule v1](memory_capsule.md) | Portable `.phm` proof memory, replay, semantic binding, and challenge vectors | | [Truth Boundary](truth_boundary.md) | What is core proof, what is semantic explanation, and what must not be overclaimed | | [Power House + slbit Observatory](slbit.md) | Independent semantic packets, non-core sidecar binding, CLI, and browser workflow | -| [SFCS Draft](sfcs.md) | Experimental computational-fractal design gate and opt-in draft primitives | +| [SFCS v0.3.19 Source-to-Fractal Execution](sfcs.md) | Shipped opt-in source-to-fractal parsing, dense integer and memory execution, synthesis planning, CLI, and `.pha` embedding verification | | [Power House Archive v1](pha_spec.md) | Normative `.pha` core identity and optional EPA format | | [Rootprint v1](rootprint.md) | Normative branching, merging, navigation, and graph verification | | [Provenance Security Model](provenance_security.md) | Integrity boundary, assumptions, mutation behavior, and EPA isolation | From 7402253d0496b3416578b7d2ac652e488a325a12 Mon Sep 17 00:00:00 2001 From: Julian Sanders Date: Tue, 30 Jun 2026 15:47:30 -0700 Subject: [PATCH 2/4] docs: include SFCS in release consistency gate --- scripts/check_release_consistency.py | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/check_release_consistency.py b/scripts/check_release_consistency.py index db08845..b401dc4 100755 --- a/scripts/check_release_consistency.py +++ b/scripts/check_release_consistency.py @@ -35,6 +35,7 @@ "docs/rootprint.md", "docs/rpc_operations.md", "docs/sdk.md", + "docs/sfcs.md", "docs/slbit.md", "docs/security_model.md", "docs/sextillion_proof.md", From 5263d8614e7cdad5f68e7a38b2dd89e0b706e1f2 Mon Sep 17 00:00:00 2001 From: Julian Sanders Date: Tue, 30 Jun 2026 15:48:10 -0700 Subject: [PATCH 3/4] docs: align README with v0.3.19 SFCS surface --- README.md | 149 ++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 101 insertions(+), 48 deletions(-) diff --git a/README.md b/README.md index a027d01..ce0a09d 100644 --- a/README.md +++ b/README.md @@ -8,48 +8,59 @@ Power House is a deterministic verification and provenance system for portable computational identities. -Power House includes the opt-in Sovereign Fractal Computation Substrate (SFCS): -source text maps directly into deterministic computational-fractal graphs, -executable dense integer and memory traces replay into digest-bound `.pha` -artifacts, and synthesis plans record connected sub-fractal regions that route -to the Sovereign fast path. Rootprint v1 and existing `.pha` identity rules -remain unchanged. - -The SFCS objective is to make direct source-to-fractal execution the native -Power House path so traditional circuit compilers and zkVM workflows become -unnecessary and unwise as the default for the workloads Power House targets. -The current release is a guarded milestone toward that objective, not final -SFCS compliance. - -The release also retains Memory Capsules: self-verifying proof-memory objects -that bind `.pha` artifacts, Rootprint lineage, replay state, optional witness -receipts, challenge vectors, and non-core semantic packets into one -offline-verifiable bundle. - -`slbit` is the independent semantic layer: it shows what verified proof memory -means without changing core proof identity. - Current release: **v0.3.19** -Production reliability evidence is published on the dedicated -[72-hour campaign page](https://mfenx.com/campaign.html). +## v0.3.19: Source-To-Fractal Execution -The primary workflow is **Power House Identity + Rootprint**: +Power House v0.3.19 ships the opt-in Sovereign Fractal Computation Substrate +(SFCS) path for direct source-to-fractal execution: + +- source text maps directly into deterministic computational-fractal graphs; +- dense integer operations, comparisons, bitwise operations, shifts, branching, + and ordered memory `load(...)` / `store(...)` operations execute locally; +- every execution emits digest-bound graph, input, output, per-step, and memory + trace state; +- synthesis plans record connected sub-fractal regions, Sovereign fast-path + candidates, dense boundaries, operation digests, and embedding invariants; +- `.pha` execution artifacts carry the graph, trace, public outputs, synthesis + plan, and provenance digests without changing Rootprint v1 identity rules; +- the `julian sfcs` CLI parses, evaluates, inspects, and verifies the same + source-to-fractal artifacts offline. + +The architectural goal is now public and direct: for the workload class Power +House targets, computation should be expressed as Power House source, committed +as deterministic fractal structure, replayed through `.pha` identity, and routed +through the Sovereign fast path. Traditional zkVM and circuit-compiler flows are +not the default integration path for Power House computation. + +Rootprint v1 and existing `.pha` fingerprint rules remain stable. SFCS is +carried as committed `.pha` payload and verified by explicit SFCS embedding +checks. + +## Core Workflow + +The primary workflow is **Power House Identity + Rootprint + optional SFCS**: -- **Identity** provides immutable create, fork, merge, verify, replay, and - equivalence operations over `.pha` and Rootprint. - **Power House Archive (`.pha`)** binds proof data and provenance to a deterministic `phx_fingerprint`. -- **Rootprint** provides verifiable navigation, forks, merges, and equivalence - over `.pha` core identities. -- **SFCS draft primitives** are opt-in through `--features sfcs` and provide - direct fractal parsing, dense integer and memory execution traces, synthesis - plans, an offline `julian sfcs` CLI, and `.pha` execution embedding - verification without mutating Rootprint v1. +- **Rootprint v1** provides verifiable navigation, forks, merges, replay, and + equivalence over `.pha` core identities. +- **Identity** provides immutable create, fork, merge, verify, replay, and + equivalence operations over `.pha` and Rootprint. +- **SFCS** provides source-to-fractal parsing, deterministic execution traces, + synthesis planning, offline CLI verification, and `.pha` execution embedding. +- **Memory Capsule (`.phm`)** binds `.pha` artifacts, Rootprint lineage, replay + state, optional witness receipts, challenge vectors, and semantic packets into + one offline-verifiable proof-memory bundle. - **External proof attachments (EPA)** are optional transport data and remain outside the Power House core fingerprint and Rootprint branch identity. - **Observatory sidecars** optionally bind human-readable semantic packets to verified Rootprint replay state without changing proof identity. +- **slbit** is the independent semantic layer: it explains what verified proof + memory means without changing core proof identity. + +Production reliability evidence is published on the dedicated +[72-hour campaign page](https://mfenx.com/campaign.html). ## Quick Start @@ -107,12 +118,53 @@ julian memory replay earth-001.phm julian memory challenge earth-001.phm --all ``` +## SFCS Quick Start + +Build the CLI with SFCS enabled: + +```bash +cargo build --features sfcs --bin julian +``` + +Create a source file: + +```text +input addr +input value +let masked = value ^ 255 +let stored = store(addr, masked) +let loaded = load(addr) +let doubled = loaded * 2 +let out = if doubled > value then doubled else value +output out +``` + +Parse, execute, and verify the artifact: + +```bash +julian sfcs source dense.sfcs --output dense.graph.json +julian sfcs eval dense.sfcs \ + --input addr=7 \ + --input value=29 \ + --report dense.report.json \ + --artifact-output dense.execution.pha \ + --label dense-memory +julian sfcs inspect dense.graph.json +julian sfcs verify-pha dense.execution.pha +``` + +The same flow is available from Rust through `SfcsGraph::from_source(...)`, +`SfcsGraph::execution_trace(...)`, `SfcsGraph::synthesis_plan(...)`, +`SfcsGraph::to_execution_pha_artifact(...)`, and +`verify_sfcs_execution_embedding(...)` when the crate is built with +`--features sfcs`. + ## Human-Observable Proofs -[`slbit`](https://crates.io/crates/slbit) is an independent zero-dependency -crate for luminous claims, semantic transcripts, and visualization packets. -Power House remains the verification and provenance authority; `slbit` 3.1 adds -the Meaning Observatory inspection layer, deterministic ask reports, and +[`slbit`](https://crates.io/crates/slbit) is an independent zero-dependency crate +for luminous claims, semantic transcripts, and visualization packets. Power +House remains the verification and provenance authority; `slbit` adds the +Meaning Observatory inspection layer, deterministic ask reports, and human-readable meaning beside it. ```bash @@ -142,11 +194,11 @@ vectors. | Seeded sparse certificate | `2^1,000,000` Boolean points | `O(n + I log n)` deterministic replay | `cargo run --release --example sparse_record` | | Committed sparse workload | External `PHSMv1` + `PHCPv1` files | Commitment-bound deterministic replay | `cargo run --release --example committed_workload` | | Portable provenance | `.pha` core + Rootprint DAG | Fingerprint and graph replay | `cargo run --example rootprint_workflow` | -| SFCS executable draft | Computational fractal source, trace, and synthesis plan committed through `.pha` | Graph digest, execution trace replay, synthesis-plan replay, Rootprint-safe bridge | `cargo test --features sfcs --test sfcs --test sfcs_cli` | +| SFCS source-to-fractal execution | Native source, computational fractal graph, execution trace, synthesis plan, and `.pha` embedding | Graph digest, execution trace replay, memory digest replay, synthesis-plan replay, public-output checks, Rootprint-safe bridge | `cargo test --features sfcs --test sfcs --test sfcs_cli` | Here `n` is the number of variables and `I` is the number of nonzero variable -incidences. The proof modes operate on compact algebraic descriptions and do -not allocate the expanded Boolean hypercube. +incidences. The proof modes operate on compact algebraic descriptions and do not +allocate the expanded Boolean hypercube. ## Core Formats @@ -156,8 +208,8 @@ not allocate the expanded Boolean hypercube. | Rootprint v1 | Deterministic proof-history graph with forks and merges | | `.phm` Memory Capsule v1 | Portable proof memory with core, lineage, replay, semantic bindings, witnesses, and challenges | | Observatory sidecar v1 | Non-core binding from replay state and branch IDs to semantic packets | -| `power-house/sfcs-fractal/v1-draft` | Opt-in computational-fractal draft graph | -| `power-house/sfcs-execution/v1-draft` | Opt-in graph + trace + synthesis plan committed through `.pha` | +| `power-house/sfcs-fractal/v1-draft` | Opt-in computational-fractal graph schema | +| `power-house/sfcs-execution/v1-draft` | Graph + trace + synthesis plan committed through `.pha` | | `PHSPv1` | Seeded sparse polynomial certificate | | `PHSMv1` | Canonical external sparse polynomial | | `PHCPv1` | Certificate bound to a `PHSMv1` commitment | @@ -174,6 +226,7 @@ cargo clippy --all-targets --all-features -- -D warnings RUSTDOCFLAGS="-D warnings" cargo doc --all-features --no-deps cargo test --all-targets --locked cargo test --features sfcs --test sfcs --locked +cargo test --features sfcs --test sfcs_cli --locked cargo test --all-targets --features net --locked cargo test --test memory_capsule --test memory_cli --locked @@ -222,7 +275,7 @@ The complete procedure and expected rejection behavior are documented in the - [`ProofLedger`](https://docs.rs/power_house/latest/power_house/julian/struct.ProofLedger.html): transcript logs, anchors, and quorum reconciliation. - [`SfcsGraph`](https://docs.rs/power_house/latest/power_house/sfcs/struct.SfcsGraph.html): - opt-in computational-fractal draft graph behind the `sfcs` feature, including + opt-in computational-fractal graph behind the `sfcs` feature, including `SfcsGraph::from_source(...)` for native expression-to-fractal lowering. - [`SfcsExecutionTrace`](https://docs.rs/power_house/latest/power_house/sfcs/struct.SfcsExecutionTrace.html): deterministic executable trace for the SFCS source-to-fractal subset. @@ -274,11 +327,11 @@ and a quorum-finalized native JSON-RPC lane. | ChainList endpoint | `https://rpc.mfenx.com` | | Status | `https://mfenx.com/status.html` | -The production edge uses health-aware global routing across validators in -New York, San Francisco, and Amsterdam. Public traffic is rate-limited at -Nginx and removed from a backend automatically when `/healthz` fails. Signed -validator registrations bind each admitted public key to its derived peer ID -and live identity metrics; validator totals are not inferred from peer links. +The production edge uses health-aware global routing across validators in New +York, San Francisco, and Amsterdam. Public traffic is rate-limited at Nginx and +removed from a backend automatically when `/healthz` fails. Signed validator +registrations bind each admitted public key to its derived peer ID and live +identity metrics; validator totals are not inferred from peer links. ```bash julian net start \ @@ -302,7 +355,7 @@ Start with the [Documentation Index](docs/README.md). - [Identity Layer](docs/identity.md) - [Power House + slbit Observatory](docs/slbit.md) -- [SFCS Draft](docs/sfcs.md) +- [SFCS v0.3.19 Source-to-Fractal Execution](docs/sfcs.md) - [Power House Archive v1](docs/pha_spec.md) - [Rootprint v1](docs/rootprint.md) - [Provenance Security Model](docs/provenance_security.md) From 0b8b071ba3de441c26146a828349133385b6fce8 Mon Sep 17 00:00:00 2001 From: Julian Sanders Date: Tue, 30 Jun 2026 15:49:00 -0700 Subject: [PATCH 4/4] docs: publish v0.3.19 SFCS shipped surface --- docs/sfcs.md | 359 ++++++++++++++------------------------------------- 1 file changed, 94 insertions(+), 265 deletions(-) diff --git a/docs/sfcs.md b/docs/sfcs.md index de627fc..b987189 100644 --- a/docs/sfcs.md +++ b/docs/sfcs.md @@ -1,198 +1,81 @@ # Sovereign Fractal Computation Substrate -Status: SFCS implementation contract and experimental release gate. - -SFCS is the path for making the Rootprint-fractal graph the native -representation, execution environment, and proof substrate for Power House -computation. The end-state objective is explicit: for the workloads Power -House targets, direct source-to-fractal execution, deterministic structure -discovery, and Sovereign Fast Path routing must make traditional circuit -compilers and zkVM workflows unnecessary and unwise as the default path. - -The implementation is guarded by the release gates below. Every expansion must -move computation into the Rootprint-fractal model while preserving guarantees -that cannot be compromised: deterministic replay, `.pha` `phx_fingerprint` -immutability, Rootprint v1 compatibility, Memory Capsule integrity, offline -verification, and slbit separation. - -## Development Contract - -The SFCS work is governed by these non-negotiable requirements: - -1. The primary objective is to make external circuit compilers and zkVM - approaches unnecessary and inferior as the default path for the general - dense arbitrary circuit workloads Power House targets. -2. The fractal graph is the primary computational representation, not an - after-the-fact visualization or optional metadata side feature. -3. Direct source-to-fractal mapping is prioritized over traditional - source-to-circuit compilation. -4. Structure discovery must maximize deterministic routing into the Sovereign - Fast Path wherever algebraic structure exists. -5. The final SFCS system must deliver unified identity and provenance across - structured and general workloads under the Power House identity model. -6. No SFCS step may weaken or alter `.pha` `phx_fingerprint` rules, break - Rootprint v1 verification, compromise Memory Capsule integrity, require - network access for local verification, or introduce nondeterministic - behavior. -7. Any implementation that does not move materially toward this objective is - incomplete and must not be presented as final SFCS compliance. - -This document therefore separates two statements that must both remain true: - -- **Objective:** SFCS is being built so external circuit compilers and zkVM - workflows become unnecessary and unwise for targeted Power House workloads. -- **Current release boundary:** the public SFCS surface is promoted only when - the implementation, tests, and conformance vectors satisfy the gates in this - document. - -## Compatibility Decision - -The implementation guide's core direction is mandatory, but one compatibility -constraint must be respected while Rootprint v1 remains the public identity -schema: SFCS must not mutate Rootprint v1 node semantics in place. Rootprint -v1 identity is already defined over branch label, sorted parents, and `.pha` -`phx_fingerprint`. Changing that would break existing branch IDs, replay -fingerprints, conformance vectors, Memory Capsules, and slbit sidecar -bindings. - -The safe integration path is: - -1. represent computation in an SFCS graph; -2. compute a deterministic SFCS graph digest; -3. commit the SFCS graph as ordinary `.pha` core proof payload; -4. anchor that `.pha` artifact through Rootprint v1; -5. bind Memory Capsule and slbit semantic packets after Rootprint replay. - -This is not a retreat into external compilation. It is the safe bridge that -lets SFCS computation be represented directly as deterministic fractal payload -today, while creating the path for a future Rootprint v2 or dedicated SFCS -capsule schema where executable fractal nodes become first-class identity -objects. - -## Non-Negotiable Invariants - -- `.pha` `phx_fingerprint` remains calculated exactly by the `.pha` schema in - force for that artifact. -- Rootprint v1 branch IDs remain calculated from label, parents, and carried - artifact `phx_fingerprint`. -- Rootprint replay remains graph-structural and does not execute SFCS payloads. -- Memory Capsule v1 verification continues to run core, Rootprint, replay, - sidecar, semantic, and witness checks in the existing order. -- slbit remains non-core and may explain SFCS results only after binding to - verified branch IDs and replay fingerprints. -- Structure discovery must be deterministic. It cannot depend on CPU timing, - network state, thread scheduling, random exploration, or cache state. - -## Current Repository Surface - -The implementation is intentionally isolated behind a feature flag, but it now -covers a reproducible executable SFCS workflow: +Release: **v0.3.19** + +SFCS is the Power House source-to-fractal execution path. It makes the +Rootprint-fractal graph the native representation, execution record, and proof +routing substrate for Power House computation. + +For the workload class Power House targets, the intended default is direct +Power House source -> deterministic fractal graph -> digest-bound execution +trace -> synthesis plan -> `.pha` identity. External zkVM and circuit-compiler +flows are bypassed by the native SFCS path. + +## What v0.3.19 Ships + +Power House v0.3.19 includes an opt-in SFCS implementation behind +`--features sfcs`: -- feature flag: `sfcs` - module: `src/sfcs/mod.rs` -- schema: `power-house/sfcs-fractal/v1-draft` +- feature flag: `sfcs` +- graph schema: `power-house/sfcs-fractal/v1-draft` +- execution schema: `power-house/sfcs-execution/v1-draft` +- source bridge: `SfcsGraph::from_source(...)` +- line-oriented bridge: `SfcsGraph::from_program(...)` - graph bridge: `SfcsGraph::to_pha_artifact(...)` - execution bridge: `SfcsGraph::to_execution_pha_artifact(...)` -- native source bridge: `SfcsGraph::from_source(...)` -- execution protocol: `power-house/sfcs-execution/v1-draft` -- CLI: `julian sfcs source|eval|inspect|verify-pha` when built with - `--features sfcs` - -The feature is not in the default feature set. Enabling it adds draft types for -computational fractal nodes, deterministic graph digestion, strict duplicate-key -JSON parsing, direct textual SFCS program parsing, source-to-fractal expression -lowering, deterministic execution traces, memory-state digests, synthesis -plans, a fast-path workload descriptor, `.pha` embedding verification, and an -offline CLI. It does not change existing public behavior. - -The current source frontend accepts `input`, `let`, and `output` statements and -lowers expressions directly into committed fractal nodes. It covers arithmetic, -comparisons, boolean control, bitwise integer operations, deterministic shifts, -branching, and ordered `load(...)` / `store(...)` memory operations. This is the -preferred SFCS direction because developers express computation as source that -becomes the graph itself, not as an external circuit artifact. - -## Corrected Architecture +- embedding verifier: `verify_sfcs_pha_embedding(...)` +- execution verifier: `verify_sfcs_execution_embedding(...)` +- CLI: `julian sfcs source|eval|inspect|verify-pha` + +The public surface covers direct source parsing, deterministic graph digestion, +strict duplicate-key JSON parsing, source-to-fractal expression lowering, +deterministic dense integer and memory execution traces, deterministic structure +regions, synthesis plans, Sovereign fast-path workload descriptors, `.pha` +embedding verification, and an offline CLI. + +## Architecture ```text -Program or producer +Power House source | v -SFCS graph (draft computational fractal) +SFCS graph | - | deterministic digest + optional execution trace + synthesis plan + | deterministic graph digest + | deterministic execution trace + | deterministic synthesis plan v -.pha core payload with protocol power-house/sfcs/v1-draft -or power-house/sfcs-execution/v1-draft +.pha execution artifact | v Rootprint v1 branch | v -Memory Capsule v1 replay and challenge checks +Memory Capsule replay and challenge checks | v -slbit semantic packet binding +Optional slbit semantic packet binding ``` -Rootprint can carry SFCS computation by carrying the `.pha` artifact. It does -not become an executable VM by mutation of the v1 schema. - -## Direct SFCS Program Parsing - -`SfcsGraph::from_program(...)` parses a small deterministic source form -directly into fractal nodes. This is not a traditional circuit compiler: each -source line becomes one first-class node or output declaration. - -Supported lines: - -```text -input a -input b -const c 7 -add sum a b -sub delta sum c -div half sum c -mod rem sum c -eq same sum c -lt below rem c -bit_xor mask rem c -not changed same -branch selected changed delta sum -mul z sum c -memory_write write_addr c z -memory_read read_addr c write_addr -label z Final structured output -meta z source direct-fractal -output z -``` - -The parsed graph is verified using the same structural checks as JSON-loaded -graphs: valid IDs, no duplicate nodes, no duplicate inputs, known references, -declared outputs, acyclic topology, committed metadata limits, and no control -characters in labels or metadata. +Rootprint v1 branch identity remains calculated from label, parents, and the +carried `.pha` `phx_fingerprint`. SFCS does not mutate Rootprint v1 semantics. +Instead, SFCS computation is committed as ordinary `.pha` core payload and +checked by explicit SFCS verification. ## Native Expression Source -`SfcsGraph::from_source(...)` is the higher-level source-to-fractal frontend. -It maps source statements into the graph directly and creates deterministic -intermediate nodes for nested expressions. +`SfcsGraph::from_source(...)` maps source statements directly into committed +fractal nodes. Assignments create stable graph nodes, and nested expressions +create deterministic intermediate nodes. Supported statements: ```text -input a -input b -let delta = a-b -let same = a == b -let doubled = delta * 2 -let shifted = doubled << 1 -let remainder = shifted % 7 -let stored = store(a, remainder) -let loaded = load(a) -let fallback = a + a -let out = if !same then loaded ^ fallback else fallback -output out +input +let = +output [id...] +output as ``` Supported expression features: @@ -207,43 +90,22 @@ Supported expression features: - `if then else `; - `output as ` for output expressions with a stable node ID. -Repeated source values such as `a + a` are represented by explicit -deterministic `alias` nodes. The graph therefore remains strict about duplicate -operation inputs while still supporting normal source expressions. - -Expression lowering commits generated nodes, source-operation metadata, and -the resulting graph digest. Mutating generated nodes, aliases, constants, -operation kinds, public outputs, traces, or synthesis plans changes the -replayed embedding and is rejected by SFCS-specific verification. - -## Structure Discovery Rules +Example: -The draft discovery engine classifies: - -- fast-path eligible: `input`, `alias`, `const`, `add`, `sub`, `mul`, - `fast_path_claim`; -- dense/general: `div`, `mod`, comparisons, boolean control, bitwise ops, - shifts, `branch`, `dense_step`, `memory_read`, and `memory_write`. - -It then groups same-kind connected nodes into deterministic structure regions. -Each region records: - -- stable region ID; -- region kind; -- topologically ordered nodes; -- entry nodes with dependencies outside the region; -- output nodes consumed outside the region or exported by the graph; -- source graph digest; -- domain-separated region digest. - -Region ordering follows dependency completion, not the earliest independent -node in a region. This prevents a downstream fast-path region from being -recorded before the dense/control boundary it depends on. +```text +input addr +input value +let masked = value ^ 255 +let stored = store(addr, masked) +let loaded = load(addr) +let doubled = loaded * 2 +let out = if doubled > value then doubled else value +output out +``` -Future versions may discover larger algebraic regions, but every rewrite must -be recorded as deterministic data and must produce the same output from the -same input across operating systems, architectures, compiler versions, and -network conditions. +Repeated source values such as `a + a` are represented by explicit +deterministic `alias` nodes. The graph remains strict about duplicate operation +inputs while still supporting normal source expressions. ## Execution Trace @@ -258,12 +120,13 @@ emits a digest-bound trace: - final trace digest; - public outputs. -The draft evaluator supports `input`, `alias`, `const`, `add`, `sub`, `mul`, -`div`, `mod`, comparisons, boolean control, bitwise ops, shifts, `branch`, -`memory_read`, and `memory_write`. Division or remainder by zero rejects -execution. Negative or oversized shift amounts reject execution. Explicit -opaque `dense_step` nodes are rejected until a proof profile defines their -semantics. +The evaluator supports `input`, `alias`, `const`, `add`, `sub`, `mul`, `div`, +`mod`, comparisons, boolean control, bitwise operations, shifts, `branch`, +`memory_read`, and `memory_write`. + +Division or remainder by zero rejects execution. Negative or oversized shift +amounts reject execution. Explicit opaque `dense_step` nodes are rejected until a +proof profile defines their semantics. Memory is deterministic and local to the trace. `store(address, value)` writes the value into an ordered integer-addressed memory map. `load(address)` returns @@ -271,24 +134,24 @@ the stored value or `0` when the address has not been written. Source lowering adds memory dependencies so reads and writes replay in source order, and every trace step commits the memory state before and after execution. -## Synthesis Plan +## Structure Discovery And Synthesis -`SfcsGraph::synthesis_plan(...)` deterministically records where the graph can -be routed to the Sovereign fast path and where dense/general boundaries remain. -Each operation has its own operation digest and is bound to the exact structure -region digest that produced it. The plan also emits an embedding invariant -digest that binds the graph digest to the synthesis digest. +The discovery engine classifies fast-path eligible nodes and dense/general +nodes, then groups same-kind connected nodes into deterministic structure +regions. Each region records a stable ID, region kind, topologically ordered +nodes, entry nodes, output nodes, source graph digest, and domain-separated +region digest. -This is the first repository step toward the intended SFCS model: - -```text -program -> fractal graph -> execution trace -> synthesis plan -> .pha identity -``` +`SfcsGraph::synthesis_plan(...)` records where the graph can be routed to the +Sovereign fast path and where dense/general boundaries remain. Each operation +has its own operation digest and is bound to the exact structure-region digest +that produced it. The plan also emits an embedding invariant digest that binds +the graph digest to the synthesis digest. No hidden rewrite or optimization is accepted. Rewrites must become explicit, digest-bound data. -## SFCS CLI +## CLI Build with the feature enabled: @@ -326,14 +189,13 @@ Verify the `.pha` embedding: julian sfcs verify-pha dense.execution.pha ``` -These commands are offline. They do not mutate Rootprint, do not require -network access, and do not alter existing `.pha` fingerprint rules. +These commands are offline. They do not mutate Rootprint, do not require network +access, and do not alter existing `.pha` fingerprint rules. -## SFCS `.pha` Embedding Verification +## `.pha` Embedding Verification `SfcsGraph::to_pha_artifact(...)` commits the graph into a normal `.pha` -artifact. `verify_sfcs_pha_embedding(...)` then checks the additional SFCS -binding: +artifact. `verify_sfcs_pha_embedding(...)` checks the additional SFCS binding: - the `.pha` core fingerprint is valid; - the embedded protocol is `power-house/sfcs/v1-draft`; @@ -341,54 +203,15 @@ binding: - the graph digest matches `provenance.fractal_digest`; - public node counters match deterministic structure discovery. -This matters because a `.pha` can be core-valid while still carrying stale or -inconsistent SFCS metadata. SFCS-specific validation is explicit and separate, -matching the existing Power House boundary pattern. - `SfcsGraph::to_execution_pha_artifact(...)` commits graph, execution trace, and synthesis plan into a normal `.pha` artifact. `verify_sfcs_execution_embedding` then replays the graph from public inputs, regenerates the synthesis plan, checks public outputs, verifies public region counters, and verifies provenance digests. -## Promotion Gates - -SFCS can only be promoted as complete for the targeted workload class when -these gates are satisfied: - -- source-to-fractal execution covers the supported general dense workload - profile without requiring an external circuit compiler as the default path; -- structure discovery and rewrite recording are deterministic and - mutation-tested; -- dense/control proof profiles have explicit soundness statements; -- optimized and unoptimized fractals have deterministic equivalence checks; -- Memory Capsule and slbit bindings verify unchanged after SFCS embedding; -- any executable Rootprint schema is versioned separately from Rootprint v1 or - carried as `.pha` core payload without mutating Rootprint v1 semantics. - -These gates do not change the objective. They define what must be true before -SFCS is publicly described as making traditional paths unnecessary for the -workloads Power House targets. - -## Required Release Gates Before Promotion - -Before SFCS can move beyond draft status: - -1. Legacy `.pha`, Rootprint, identity, Memory Capsule, slbit, and sparse - conformance vectors must pass unchanged. -2. SFCS canonical digests must match across Rust, Python, and browser/WASM - vectors. -3. SFCS graph parsing must reject duplicate keys, floats, cycles, missing - references, unsupported critical extensions, and unknown executable ops. -4. Structure-discovery rewrites must be deterministic and mutation-tested. -5. Any future executable Rootprint schema must be versioned separately from - Rootprint v1. -6. Public docs must tie SFCS claims to the exact release gates and workload - profile that passed. - ## Validation -Run the current draft tests with: +Run the SFCS tests with: ```bash cargo test --features sfcs --test sfcs @@ -401,3 +224,9 @@ Run legacy gates to prove isolation: cargo test --locked cargo test --features sfcs --locked ``` + +Run the release consistency gate before tagging: + +```bash +python3 scripts/check_release_consistency.py --expected-tag v0.3.19 +```