feat(prover): add composable prover interface

.github/workflows/blake3-nonregression.yml

@@ -51,7 +51,7 @@ on:
         default: "200,15,3"
         type: string
       bench_axes:
-        description: "Comma-separated axes: all, execute_trace_inputs_sync, build_trace, prove_trace_sync, e2e_prove."
+        description: "Comma-separated axes: all, execute_for_proving_sync, build_trace, prove_trace_sync, e2e_prove."
         required: false
         default: "all"
         type: string

CHANGELOG.md

@@ -50,6 +50,16 @@
 - [BREAKING] Removed unused public APIs and narrowed test-only helper visibility across VM and crypto crates ([#3424](https://github.com/0xMiden/miden-vm/pull/3424)).
 - Enable simd128 Plonky3 backend for WASM builds and added related CI job ([#3433](https://github.com/0xMiden/miden-vm/pull/3433)).
 - [BREAKING] Bumped Plonky3 related dependencies to integrate SVE2 and WASM-SIMD128 speed-ups and include a NEON bugfix. ([#3441](https://github.com/0xMiden/miden-vm/pull/3441)).
+- [BREAKING] Superseded the preceding unreleased partial-proof and configurable-verifier APIs with
+  checked `ExecutionWitness` and `VmWitness` artifacts, VM-first `Prover` methods,
+  deferred/complete `ExecutionProof` states, and borrowed verification that reports any
+  authenticated outstanding precompile root. The intermediate `prove_partial*`,
+  `Verifier::verify_partial`, and `Verifier::with_max_deferred_elements` APIs were removed. Proof
+  encoding preserves representation without establishing validity, with standard and
+  custom-registry decode paths carrying deferred-element bounds. A deferred proof retains a
+  hydrated `PrecompileWitness`; `DeferredStateWire` is its transport representation, not the
+  in-memory proof payload. See the PR description for the complete migration guide
+  ([#3437](https://github.com/0xMiden/miden-vm/pull/3437)).
 
 #### Fixes
 

README.md

@@ -109,7 +109,11 @@ RAYON_NUM_THREADS=16 cargo run --profile optimized -p miden-vm-blake3-bench --bi
   --git-ref "$(git rev-parse HEAD)"
 ```
 
-The result is written to `target/blake3-nonregression/result.json`; the harness does not parse the `miden-vm run` or `miden-vm prove` text output. The benchmark records `execute_trace_inputs_sync`, `build_trace`, `prove_trace_sync`, and `e2e_prove`. The `e2e_prove` metric runs execution and trace generation on each sample, but only measures the prover span. The harness also proves and verifies the program once before timing proof-heavy axes.
+The result is written to `target/blake3-nonregression/result.json`; the harness does not parse
+the `miden-vm run` or `miden-vm prove` text output. The benchmark records
+`execute_for_proving_sync`, `build_trace`, `prove_trace_sync`, and `e2e_prove`. The `e2e_prove`
+metric runs execution and trace generation on each sample, but only measures the prover span. The
+harness also proves and verifies the program once before timing proof-heavy axes.
 
 ### Single-core prover performance
 

benches/blake3-bench/benches/blake3_bench.rs

@@ -3,19 +3,19 @@ use std::{hint::black_box, time::Duration};
 use codspeed_criterion_compat as criterion;
 use criterion::{BatchSize, Criterion, SamplingMode, criterion_group, criterion_main};
 use miden_vm_blake3_bench::{
-    BENCH_GROUP, Blake3Fixture, build_trace, execute_program, execute_trace_inputs,
+    BENCH_GROUP, Blake3Fixture, build_trace, execute_for_proving, execute_program,
     prove_and_verify_once, prove_span_duration, prove_trace, repo_root_from_manifest,
 };
 
 const ALL_AXES: [&str; 5] = [
     "execute_sync",
-    "execute_trace_inputs_sync",
+    "execute_for_proving_sync",
     "build_trace",
     "prove_trace_sync",
     "e2e_prove",
 ];
 const PROOF_AXES: [&str; 2] = ["e2e_prove", "prove_trace_sync"];
-const LIGHT_AXES: [&str; 3] = ["execute_sync", "execute_trace_inputs_sync", "build_trace"];
+const LIGHT_AXES: [&str; 3] = ["execute_sync", "execute_for_proving_sync", "build_trace"];
 
 fn env_usize(name: &str, default: usize) -> usize {
     match std::env::var(name) {
@@ -55,7 +55,7 @@ fn resolve_axes() -> Vec<&'static str> {
             "all" => requested.extend(ALL_AXES),
             "e2e_prove" | "prove" | "prove_program_sync" => requested.push("e2e_prove"),
             "execute_sync" => requested.push("execute_sync"),
-            "execute_trace_inputs_sync" => requested.push("execute_trace_inputs_sync"),
+            "execute_for_proving_sync" => requested.push("execute_for_proving_sync"),
             "prove_trace_sync" => requested.push("prove_trace_sync"),
             "build_trace" => requested.push("build_trace"),
             _ => panic!(
@@ -116,10 +116,10 @@ fn blake3_bench(c: &mut Criterion) {
         if has_axis(&axes, "prove_trace_sync") {
             group.bench_function("prove_trace_sync", |b| {
                 b.iter_batched(
-                    || execute_trace_inputs(&fixture),
-                    |trace_inputs| {
-                        let trace_inputs = black_box(trace_inputs);
-                        prove_trace(trace_inputs);
+                    || execute_for_proving(&fixture),
+                    |execution_witness| {
+                        let execution_witness = black_box(execution_witness);
+                        prove_trace(execution_witness);
                     },
                     BatchSize::SmallInput,
                 );
@@ -151,11 +151,11 @@ fn blake3_bench(c: &mut Criterion) {
             });
         }
 
-        if has_axis(&axes, "execute_trace_inputs_sync") {
-            group.bench_function("execute_trace_inputs_sync", |b| {
+        if has_axis(&axes, "execute_for_proving_sync") {
+            group.bench_function("execute_for_proving_sync", |b| {
                 b.iter_batched(
                     || fixture.clone(),
-                    |fixture| black_box(execute_trace_inputs(&fixture)),
+                    |fixture| black_box(execute_for_proving(&fixture)),
                     BatchSize::SmallInput,
                 );
             });
@@ -164,10 +164,10 @@ fn blake3_bench(c: &mut Criterion) {
         if has_axis(&axes, "build_trace") {
             group.bench_function("build_trace", |b| {
                 b.iter_batched(
-                    || execute_trace_inputs(&fixture),
-                    |trace_inputs| {
-                        let trace_inputs = black_box(trace_inputs);
-                        build_trace(trace_inputs);
+                    || execute_for_proving(&fixture),
+                    |execution_witness| {
+                        let execution_witness = black_box(execution_witness);
+                        build_trace(execution_witness);
                     },
                     BatchSize::SmallInput,
                 );

benches/blake3-bench/src/bin/blake3_nonregression/criterion_results.rs

@@ -69,7 +69,7 @@ fn select_primary_metric(
         PRIMARY_METRIC,
         "prove_trace_sync",
         "build_trace",
-        "execute_trace_inputs_sync",
+        "execute_for_proving_sync",
         "execute_sync",
     ]
     .into_iter()
@@ -153,9 +153,9 @@ pub(crate) fn selected_criterion_axes(bench_axes: &str) -> Option<BTreeSet<Strin
 
 fn report_span_metric_name(name: &str) -> Option<String> {
     match name {
-        "execute_trace_inputs_with_package_debug_info_sync"
-        | "execute_trace_inputs_with_package_debug_info_at_source_node_sync" => {
-            Some("execute_trace_inputs_sync".to_string())
+        "execute_for_proving_with_package_debug_info_sync"
+        | "execute_for_proving_with_package_debug_info_at_source_node_sync" => {
+            Some("execute_for_proving_sync".to_string())
         },
         "build aux traces" => Some("build_aux_trace".to_string()),
         "to_core_chiplets_matrices" => Some("to_row_major_matrix".to_string()),

benches/blake3-bench/src/lib.rs

@@ -6,16 +6,16 @@ use std::{
 
 use miden_core_lib::CoreLibrary;
 use miden_vm::{
-    Assembler, DefaultHost, ExecutionOptions, FastProcessor, HashFunction, Program, ProvingOptions,
-    StackInputs, TraceBuildInputs, TraceProvingInputs, Verifier,
+    Assembler, DefaultHost, ExecutionOptions, ExecutionWitness, FastProcessor, HashFunction,
+    Program, Prover, StackInputs, Verifier,
     advice::AdviceInputs,
     assembly::{
         DefaultSourceManager, Path as LibraryPath,
         ast::{Module, ModuleKind},
         package::debug_info::{DebugSourceNodeId, PackageDebugInfo},
     },
     internal::InputFile,
-    prove_from_trace_sync, trace,
+    trace,
 };
 use serde::{Deserialize, Serialize};
 use tracing::{Subscriber, span};
@@ -89,10 +89,6 @@ pub fn execution_options() -> ExecutionOptions {
     .expect("CLI-compatible Blake3 execution options should be valid")
 }
 
-pub fn proving_options() -> ProvingOptions {
-    ProvingOptions::with_96_bit_security(HashFunction::Blake3_256)
-}
-
 pub fn default_host() -> DefaultHost {
     DefaultHost::default()
         .with_library(&CoreLibrary::default())
@@ -103,7 +99,7 @@ fn host_for_fixture(fixture: &Blake3Fixture) -> DefaultHost<DefaultSourceManager
     default_host().with_source_manager(fixture.source_manager.clone())
 }
 
-pub fn execute_trace_inputs(fixture: &Blake3Fixture) -> TraceBuildInputs {
+pub fn execute_for_proving(fixture: &Blake3Fixture) -> ExecutionWitness {
     let mut host = host_for_fixture(fixture);
     let processor = FastProcessor::new_with_options(
         fixture.stack_inputs,
@@ -113,22 +109,22 @@ pub fn execute_trace_inputs(fixture: &Blake3Fixture) -> TraceBuildInputs {
     .expect("processor advice inputs should fit advice map limits");
     match (fixture.debug_info.as_ref(), fixture.entrypoint_source_node) {
         (Some(debug_info), Some(entrypoint_source_node)) => processor
-            .execute_trace_inputs_with_package_debug_info_at_source_node_sync(
+            .execute_for_proving_with_package_debug_info_at_source_node_sync(
                 &fixture.program,
                 debug_info,
                 entrypoint_source_node,
                 &mut host,
             )
             .expect("failed to execute Blake3 benchmark"),
         (Some(debug_info), None) => processor
-            .execute_trace_inputs_with_package_debug_info_sync(
+            .execute_for_proving_with_package_debug_info_sync(
                 &fixture.program,
                 debug_info,
                 &mut host,
             )
             .expect("failed to execute Blake3 benchmark"),
         (None, _) => processor
-            .execute_trace_inputs_sync(&fixture.program, &mut host)
+            .execute_for_proving_sync(&fixture.program, &mut host)
             .expect("failed to execute Blake3 benchmark"),
     }
 }
@@ -148,36 +144,37 @@ pub fn execute_program(fixture: &Blake3Fixture) {
 
 pub fn prove_program(fixture: &Blake3Fixture) {
     let _span = tracing::info_span!("prove_program_sync").entered();
-    prove_trace(execute_trace_inputs(fixture));
+    prove_trace(execute_for_proving(fixture));
 }
 
-pub fn prove_trace(trace_inputs: TraceBuildInputs) {
-    let _ = prove_trace_outputs(trace_inputs);
+pub fn prove_trace(witness: ExecutionWitness) {
+    let _ = prove_trace_outputs(witness);
 }
 
 pub fn prove_and_verify_once(fixture: &Blake3Fixture) {
-    let stack_inputs = fixture.stack_inputs;
-    let trace_inputs = execute_trace_inputs(fixture);
-    let (stack_outputs, proof) = prove_trace_outputs(trace_inputs);
-    let claim = miden_vm::ExecutionClaim::from_program_info(
-        fixture.program.to_info(),
-        stack_inputs,
-        stack_outputs,
-    );
-    Verifier::new()
-        .verify(proof, claim)
+    let witness = execute_for_proving(fixture);
+    let claim = witness.claim();
+    let (_, proof) = prove_trace_outputs(witness);
+    let outcome = Verifier::new()
+        .verify(&claim, &proof)
         .expect("failed to verify Blake3 benchmark proof");
+    assert!(outcome.is_complete(), "prove_full must settle all precompile work");
 }
 
 fn prove_trace_outputs(
-    trace_inputs: TraceBuildInputs,
+    witness: ExecutionWitness,
 ) -> (miden_vm::StackOutputs, miden_vm::ExecutionProof) {
-    prove_from_trace_sync(TraceProvingInputs::new(trace_inputs, proving_options()))
-        .expect("failed to prove Blake3 benchmark trace")
+    let stack_outputs = *witness.claim().stack_outputs();
+    let proof = Prover::new()
+        .with_hash_fn(HashFunction::Blake3_256)
+        .prove_full(witness)
+        .expect("failed to prove Blake3 benchmark witness");
+    (stack_outputs, proof)
 }
 
-pub fn build_trace(trace_inputs: TraceBuildInputs) {
-    trace::build_trace(trace_inputs).expect("failed to build Blake3 execution trace");
+pub fn build_trace(witness: ExecutionWitness) {
+    let (vm_witness, _) = witness.into_parts();
+    trace::build_trace(vm_witness).expect("failed to build Blake3 execution trace");
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]

benches/synthetic-bench/Cargo.toml

@@ -23,7 +23,6 @@ codspeed-criterion-compat = { workspace = true }
 miden-assembly = { workspace = true, features = ["std"] }
 miden-core = { workspace = true, features = ["std"] }
 miden-core-lib = { workspace = true, features = ["std"] }
-miden-prover = { workspace = true, features = ["concurrent"] }
 miden-utils-testing = { workspace = true, features = ["std"] }
 
 [[bench]]