refactor: address review on the base-field first sumcheck round

- prover: precompute 1/2 once and pass it into combined_round_message
  instead of recomputing a field inverse every round (transcript-identical)
- deps: move inferno/tracing-flame to root [workspace.dependencies]
- fixtures: relocate the single-commit timed prove into harness.rs and
  point the flamegraph probe at target/profile/

Author: BornPsych

Cargo.toml

@@ -123,6 +123,7 @@ chrono = "0.4.41"
 # This is a workaround because different package selection based on target does not mix well with workspace dependencies.
 divan = "0.1.21"
 hex = "0.4.3"
+inferno = { version = "0.12", default-features = false }
 itertools = "0.14.0"
 num-bigint = "0.4"
 paste = "1.0.15"
@@ -153,6 +154,7 @@ tokio-util = "0.7.13"
 tower = "0.5.2"
 tower-http = { version = "0.6.6", features = ["cors", "timeout", "trace"] }
 tracing = "0.1.41"
+tracing-flame = "0.2"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter", "ansi"] }
 tracing-tracy = "=0.11.4"
 tracy-client = "=0.18.0"

provekit/prover/src/whir_r1cs.rs

@@ -1,7 +1,7 @@
 use {
     ::tracing::instrument,
     anyhow::{ensure, Result},
-    ark_ff::Field,
+    ark_ff::{Field, One},
     ark_std::{
         rand::distributions::{Distribution, Standard},
         Zero,
@@ -525,6 +525,10 @@ where
     // Prove that sum of F + ρ·G over the boolean hypercube equals ρ·Σ(G).
     let mut saved_val_for_sumcheck_equality_assertion = rho * sum_g_reduce;
 
+    // 2 is invertible in any field of odd characteristic; precompute 1/2 once
+    // and reuse it for each round's cubic-coefficient solve.
+    let half = M::Target::one() / (M::Target::one() + M::Target::one());
+
     // First round: a, b, c are base-field, so the constraint products stay in
     // the base field with one mixed mul per point against the ext eq.
     let hhat = mixed_sumcheck_map_reduce([&a[..], &b[..], &c[..]], &eq, |[a, b, c], eq| {
@@ -543,6 +547,7 @@ where
         hhat,
         g_poly,
         rho,
+        half,
         saved_val_for_sumcheck_equality_assertion,
     );
     saved_val_for_sumcheck_equality_assertion = saved_val;
@@ -582,6 +587,7 @@ where
             hhat,
             g_poly,
             rho,
+            half,
             saved_val_for_sumcheck_equality_assertion,
         );
         saved_val_for_sumcheck_equality_assertion = saved_val;
@@ -606,6 +612,7 @@ fn combined_round_message<F: Field + Codec, S: DuplexSpongeInterface<U = u8>>(
     hhat: [F; 3],
     g_poly: [F; 4],
     rho: F,
+    half: F,
     saved_val_for_sumcheck_equality_assertion: F,
 ) -> (F, F) {
     let [hhat_i_at_0, hhat_i_at_em1, hhat_i_at_inf_over_x_cube] = hhat;
@@ -617,12 +624,11 @@ fn combined_round_message<F: Field + Codec, S: DuplexSpongeInterface<U = u8>>(
     let g_at_minus_one = g_poly[0] - g_poly[1] + g_poly[2] - g_poly[3];
     let combined_at_em1 = hhat_i_at_em1 + rho * g_at_minus_one;
 
-    let two = F::one() + F::one();
     combined_hhat_i_coeffs[2] = (saved_val_for_sumcheck_equality_assertion + combined_at_em1
         - combined_hhat_i_coeffs[0]
         - combined_hhat_i_coeffs[0]
         - combined_hhat_i_coeffs[0])
-        / two;
+        * half;
 
     combined_hhat_i_coeffs[3] = hhat_i_at_inf_over_x_cube + rho * g_poly[3];
 

tooling/provekit-fixtures/Cargo.toml

@@ -24,9 +24,9 @@ whir.workspace = true
 # Concrete proof fields to instantiate the generic harness.
 provekit-backend-bn254.workspace = true
 provekit-backend-goldilocks.workspace = true
-inferno = { version = "0.12", default-features = false }
+inferno.workspace = true
 tracing.workspace = true
-tracing-flame = "0.2"
+tracing-flame.workspace = true
 tracing-subscriber.workspace = true
 
 [lints]

tooling/provekit-fixtures/src/harness.rs

@@ -287,3 +287,67 @@ where
     scheme.prove_noir(merlin, r1cs_owned, vec![c1, c2], full_witness, &public)?;
     Ok(start.elapsed())
 }
+
+/// Pre-built inputs for a timed single-commit prove, constructed outside the
+/// timer/flamegraph so scheme construction and the witness clones are not
+/// measured. Opaque: build with [`prove_setup`], consume with
+/// [`time_prove_core`].
+pub struct ProveInputs<P: FieldHash> {
+    scheme:         WhirR1CSScheme<P>,
+    r1cs:           R1CS<Base<P>>,
+    witness_commit: Vec<Base<P>>,
+    witness_prove:  Vec<Base<P>>,
+}
+
+/// Build the scheme and owned witness copies for a single-commit prove. Kept
+/// separate from [`time_prove_core`] so a profiler can install its subscriber
+/// between setup and the timed region (only the latter is captured).
+pub fn prove_setup<P>(r1cs: &R1CS<Base<P>>, witness: &[Base<P>]) -> ProveInputs<P>
+where
+    P: FieldHash,
+    Standard: Distribution<Ext<P>> + Distribution<Base<P>>,
+{
+    let scheme = WhirR1CSScheme::<P>::new_for_r1cs(r1cs, witness.len(), 0, Vec::new(), true, HASH);
+    ProveInputs {
+        scheme,
+        r1cs: r1cs.clone(),
+        witness_commit: witness.to_vec(),
+        witness_prove: witness.to_vec(),
+    }
+}
+
+/// Time the single-commit proving core — `commit` + `prove_noir` — from
+/// pre-built inputs, returning the elapsed time alongside the proof and scheme.
+pub fn time_prove_core<P>(
+    inp: ProveInputs<P>,
+    public_inputs: &PublicInputs<Base<P>>,
+) -> Result<(Duration, WhirR1CSProof, WhirR1CSScheme<P>)>
+where
+    P: FieldHash,
+    Standard: Distribution<Ext<P>> + Distribution<Base<P>>,
+{
+    let ProveInputs {
+        scheme,
+        r1cs,
+        witness_commit,
+        witness_prove,
+    } = inp;
+
+    // Transcript binding derives from the scheme; built before the timer starts.
+    let instance = public_inputs.hash_bytes::<P>(HASH);
+    let ds = scheme.create_domain_separator().instance(&instance);
+    let num_witnesses = r1cs.num_witnesses();
+    let num_constraints = r1cs.num_constraints();
+
+    let start = Instant::now();
+    let mut merlin = ProverState::new(&ds, P::transcript_sponge(HASH));
+    let commitment = scheme.commit(
+        &mut merlin,
+        num_witnesses,
+        num_constraints,
+        witness_commit,
+        true,
+    )?;
+    let proof = scheme.prove_noir(merlin, r1cs, vec![commitment], witness_prove, public_inputs)?;
+    Ok((start.elapsed(), proof, scheme))
+}

tooling/provekit-fixtures/tests/profile.rs

@@ -12,101 +12,22 @@
 
 use {
     ark_std::rand::distributions::{Distribution, Standard},
-    provekit_common::{
-        Base, Ext, FieldHash, HashConfig, PublicInputs, PublicInputsHash, WhirR1CSProof,
-        WhirR1CSScheme, R1CS,
+    provekit_common::{Base, Ext, FieldHash, PublicInputs},
+    provekit_fixtures::{
+        builders::squaring_chain,
+        harness::{prove_setup, time_prove_core},
     },
-    provekit_fixtures::builders::squaring_chain,
-    provekit_prover::WhirR1CSProver,
     provekit_verifier::WhirR1CSVerifier,
     std::{
         collections::HashMap,
         path::PathBuf,
         time::{Duration, Instant},
     },
-    whir::transcript::ProverState,
 };
 
 /// Log2 witness sizes to sweep.
 const SIZES: [u32; 4] = [14, 16, 18, 20];
 
-/// Instance-binding hash for the probes (matches the harness default).
-const HASH: HashConfig = HashConfig::Sha256;
-
-/// Inputs for a single-commit prove, built outside the timer so scheme
-/// construction and the `commit`/`prove_noir` ownership copies aren't measured.
-struct ProveInputs<P: FieldHash> {
-    scheme:          WhirR1CSScheme<P>,
-    r1cs_owned:      R1CS<Base<P>>,
-    witness_commit:  Vec<Base<P>>,
-    witness_prove:   Vec<Base<P>>,
-    num_witnesses:   usize,
-    num_constraints: usize,
-}
-
-/// Build the scheme + ownership copies (excluded from the timer and
-/// flamegraph).
-fn prove_setup<P>(r1cs: &R1CS<Base<P>>, witness: &[Base<P>]) -> ProveInputs<P>
-where
-    P: FieldHash,
-    Standard: Distribution<Ext<P>> + Distribution<Base<P>>,
-{
-    let scheme = WhirR1CSScheme::<P>::new_for_r1cs(r1cs, witness.len(), 0, Vec::new(), true, HASH);
-    ProveInputs {
-        scheme,
-        r1cs_owned: r1cs.clone(),
-        witness_commit: witness.to_vec(),
-        witness_prove: witness.to_vec(),
-        num_witnesses: r1cs.num_witnesses(),
-        num_constraints: r1cs.num_constraints(),
-    }
-}
-
-/// Time the proving core — `commit` + `prove_noir` — from pre-built inputs.
-fn time_prove_core<P>(
-    inp: ProveInputs<P>,
-    public_inputs: &PublicInputs<Base<P>>,
-) -> (Duration, WhirR1CSProof, WhirR1CSScheme<P>)
-where
-    P: FieldHash,
-    Standard: Distribution<Ext<P>> + Distribution<Base<P>>,
-{
-    let ProveInputs {
-        scheme,
-        r1cs_owned,
-        witness_commit,
-        witness_prove,
-        num_witnesses,
-        num_constraints,
-    } = inp;
-
-    // Transcript binding derives from the scheme; built before the timer starts.
-    let instance = public_inputs.hash_bytes::<P>(HASH);
-    let ds = scheme.create_domain_separator().instance(&instance);
-
-    let start = Instant::now();
-    let mut merlin = ProverState::new(&ds, P::transcript_sponge(HASH));
-    let commitment = scheme
-        .commit(
-            &mut merlin,
-            num_witnesses,
-            num_constraints,
-            witness_commit,
-            true,
-        )
-        .expect("commit");
-    let proof = scheme
-        .prove_noir(
-            merlin,
-            r1cs_owned,
-            vec![commitment],
-            witness_prove,
-            public_inputs,
-        )
-        .expect("prove_noir");
-    (start.elapsed(), proof, scheme)
-}
-
 /// Build a `2^log_size`-witness squaring chain, prove, verify, and return
 /// `(prove, verify, narg_bytes, hints_bytes)`.
 fn run_one<P>(log_size: u32) -> (Duration, Duration, usize, usize)
@@ -120,7 +41,7 @@ where
 
     // Only commit + prove_noir are timed (setup excluded above).
     let inp = prove_setup::<P>(&r1cs, &w);
-    let (prove_t, proof, scheme) = time_prove_core::<P>(inp, &public_inputs);
+    let (prove_t, proof, scheme) = time_prove_core::<P>(inp, &public_inputs).expect("prove");
 
     let t = Instant::now();
     scheme
@@ -187,13 +108,14 @@ fn size_sweep() {
     println!();
 }
 
-/// Repo `provekit/.claude/profile/` directory (created if absent).
+/// Workspace `target/profile/` directory (created if absent). Lives under the
+/// gitignored build dir so the artifacts are not committed and the probe is
+/// portable across machines.
 fn profile_dir() -> PathBuf {
     let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
         .join("..")
         .join("..")
-        .join("provekit")
-        .join(".claude")
+        .join("target")
         .join("profile");
     std::fs::create_dir_all(&dir).expect("create profile dir");
     dir
@@ -230,7 +152,8 @@ fn flamegraph_2pow20_bf() {
 
     // Timed + captured: the true prove core only (setup/clones already done).
     let (prove_t, proof, _scheme) =
-        time_prove_core::<provekit_backend_goldilocks::GoldilocksField>(inp, &public_inputs);
+        time_prove_core::<provekit_backend_goldilocks::GoldilocksField>(inp, &public_inputs)
+            .expect("prove");
     println!(
         "\n[flamegraph] 2^20 goldilocks-BF prove={prove_t:.3?} narg={} hints={}",
         proof.narg_string.len(),