fix: rebase PR #505 onto current main

Adapt the inline-PC work to two intervening main commits:

1. #514 replaced the old `TransitionEvaluationContext` Prover/Verifier split
   with a single generic `evaluate<F,E>(&self, step: &TableView<F,E>) ->
   FieldElement<F>`. Rewrite the two new constraints
   (`PcDoubleReadRs1Constraint`, `PcDoubleReadBorrowConstraint`) to this
   shape and use `.boxed()` for the `TransitionConstraintEvaluator`
   adapter instead of `Box::new(...)`. The evaluate<F,E> body is
   field-parametric, so the old to_extension / explicit GoldilocksExtension
   paths collapse into a single generic implementation.

2. The later commit `perf: eliminate REGISTER table by computing bus
   contributions in verifier` removed the `register` field from the
   `Traces` struct but left a dangling `register` pattern in two
   destructurings plus a `register.num_rows() * (REGISTER_COLS - ...)`
   expression. Drop the pattern, the unused `REGISTER_COLS` /
   `REGISTER_PREPROCESSED` imports, the `let n_register = ...` binding,
   and the contribution line. Add a short NOTE comment explaining the
   REGISTER table is now verifier-computed.

Also run `cargo fmt --all` over the tree to clear the remaining CI fmt
diffs introduced during the rebase (prover/src/lib.rs:257,452,528 and a
few others).

Verified:
- cargo check --workspace
- cargo clippy --workspace (default features + debug-checks) -- -D warnings
- cargo fmt --check --all
- cargo test -p stark --release --lib: 121/121 pass

Author: diegokingston

prover/src/constraints/cpu.rs

@@ -1033,6 +1033,19 @@ impl PcDoubleReadRs1Constraint {
     pub fn new(idx: usize) -> Self {
         Self { idx }
     }
+
+    fn compute<F, E>(&self, step: &TableView<F, E>) -> FieldElement<F>
+    where
+        F: IsSubFieldOf<E>,
+        E: IsField,
+    {
+        let pc_double_read = step
+            .get_main_evaluation_element(0, cols::PC_DOUBLE_READ)
+            .clone();
+        let rs1 = step.get_main_evaluation_element(0, cols::RS1).clone();
+        let val_255 = FieldElement::<F>::from(255u64);
+        pc_double_read * (rs1 - val_255)
+    }
 }
 
 impl TransitionConstraint<GoldilocksField, GoldilocksExtension> for PcDoubleReadRs1Constraint {
@@ -1044,28 +1057,12 @@ impl TransitionConstraint<GoldilocksField, GoldilocksExtension> for PcDoubleRead
         self.idx
     }
 
-    fn evaluate(
-        &self,
-        evaluation_context: &TransitionEvaluationContext<GoldilocksField, GoldilocksExtension>,
-        transition_evaluations: &mut [FieldElement<GoldilocksExtension>],
-    ) {
-        match evaluation_context {
-            TransitionEvaluationContext::Prover { frame, .. } => {
-                let step = frame.get_evaluation_step(0);
-                let pc_double_read = *step.get_main_evaluation_element(0, cols::PC_DOUBLE_READ);
-                let rs1 = *step.get_main_evaluation_element(0, cols::RS1);
-                let val_255 = FieldElement::<GoldilocksField>::from(255u64);
-                transition_evaluations[self.idx] =
-                    (pc_double_read * (rs1 - val_255)).to_extension();
-            }
-            TransitionEvaluationContext::Verifier { frame, .. } => {
-                let step = frame.get_evaluation_step(0);
-                let pc_double_read = *step.get_main_evaluation_element(0, cols::PC_DOUBLE_READ);
-                let rs1 = *step.get_main_evaluation_element(0, cols::RS1);
-                let val_255 = FieldElement::<GoldilocksExtension>::from(255u64);
-                transition_evaluations[self.idx] = pc_double_read * (rs1 - val_255);
-            }
-        }
+    fn evaluate<F, E>(&self, step: &TableView<F, E>) -> FieldElement<F>
+    where
+        F: IsSubFieldOf<E>,
+        E: IsField,
+    {
+        self.compute(step)
     }
 }
 
@@ -1079,6 +1076,20 @@ impl PcDoubleReadBorrowConstraint {
     pub fn new(idx: usize) -> Self {
         Self { idx }
     }
+
+    fn compute<F, E>(&self, step: &TableView<F, E>) -> FieldElement<F>
+    where
+        F: IsSubFieldOf<E>,
+        E: IsField,
+    {
+        let pc_double_read = step
+            .get_main_evaluation_element(0, cols::PC_DOUBLE_READ)
+            .clone();
+        let borrow = step
+            .get_main_evaluation_element(0, cols::PREV_PC_TIMESTAMP_BORROW)
+            .clone();
+        pc_double_read * borrow
+    }
 }
 
 impl TransitionConstraint<GoldilocksField, GoldilocksExtension> for PcDoubleReadBorrowConstraint {
@@ -1090,25 +1101,12 @@ impl TransitionConstraint<GoldilocksField, GoldilocksExtension> for PcDoubleRead
         self.idx
     }
 
-    fn evaluate(
-        &self,
-        evaluation_context: &TransitionEvaluationContext<GoldilocksField, GoldilocksExtension>,
-        transition_evaluations: &mut [FieldElement<GoldilocksExtension>],
-    ) {
-        match evaluation_context {
-            TransitionEvaluationContext::Prover { frame, .. } => {
-                let step = frame.get_evaluation_step(0);
-                let pc_double_read = *step.get_main_evaluation_element(0, cols::PC_DOUBLE_READ);
-                let borrow = *step.get_main_evaluation_element(0, cols::PREV_PC_TIMESTAMP_BORROW);
-                transition_evaluations[self.idx] = (pc_double_read * borrow).to_extension();
-            }
-            TransitionEvaluationContext::Verifier { frame, .. } => {
-                let step = frame.get_evaluation_step(0);
-                let pc_double_read = *step.get_main_evaluation_element(0, cols::PC_DOUBLE_READ);
-                let borrow = *step.get_main_evaluation_element(0, cols::PREV_PC_TIMESTAMP_BORROW);
-                transition_evaluations[self.idx] = pc_double_read * borrow;
-            }
-        }
+    fn evaluate<F, E>(&self, step: &TableView<F, E>) -> FieldElement<F>
+    where
+        F: IsSubFieldOf<E>,
+        E: IsField,
+    {
+        self.compute(step)
     }
 }
 
@@ -1240,9 +1238,9 @@ pub fn create_all_cpu_constraints() -> (
     next_idx += 2;
 
     // Inline PC constraints
-    other.push(Box::new(PcDoubleReadRs1Constraint::new(next_idx)));
+    other.push(PcDoubleReadRs1Constraint::new(next_idx).boxed());
     next_idx += 1;
-    other.push(Box::new(PcDoubleReadBorrowConstraint::new(next_idx)));
+    other.push(PcDoubleReadBorrowConstraint::new(next_idx).boxed());
     next_idx += 1;
 
     (is_bit, add_constraints, other, next_idx)

prover/src/lib.rs

@@ -257,12 +257,8 @@ impl VmAirs {
 
     /// Collect AIR references for [`Verifier::multi_verify`].
     pub fn air_refs(&self) -> Vec<&dyn AIR<Field = F, FieldExtension = E, PublicInputs = ()>> {
-        let mut refs: Vec<&dyn AIR<Field = F, FieldExtension = E, PublicInputs = ()>> = vec![
-            &self.bitwise,
-            &self.decode,
-            &self.halt,
-            &self.commit,
-        ];
+        let mut refs: Vec<&dyn AIR<Field = F, FieldExtension = E, PublicInputs = ()>> =
+            vec![&self.bitwise, &self.decode, &self.halt, &self.commit];
 
         for air in &self.cpus {
             refs.push(air);
@@ -452,7 +448,11 @@ pub(crate) fn compute_commit_bus_offset(
         .collect();
 
     FieldElement::inplace_batch_inverse(&mut fingerprints).ok()?;
-    Some(fingerprints.iter().fold(FieldElement::zero(), |acc, inv| acc + inv))
+    Some(
+        fingerprints
+            .iter()
+            .fold(FieldElement::zero(), |acc, inv| acc + inv),
+    )
 }
 
 /// Compute the bus balance offset for the REGISTER table on the Memory bus.
@@ -528,16 +528,12 @@ pub(crate) fn compute_register_bus_offset(
 
     FieldElement::inplace_batch_inverse(&mut fingerprints).ok()?;
 
-    let total = fingerprints
-        .iter()
-        .zip(signs.iter())
-        .fold(FieldElement::<E>::zero(), |acc, (inv, &sign)| {
-            if sign > 0 {
-                acc + inv
-            } else {
-                acc - inv
-            }
-        });
+    let total = fingerprints.iter().zip(signs.iter()).fold(
+        FieldElement::<E>::zero(),
+        |acc, (inv, &sign)| {
+            if sign > 0 { acc + inv } else { acc - inv }
+        },
+    );
 
     Some(total)
 }

prover/src/tables/trace_builder.rs

@@ -723,8 +723,8 @@ fn collect_halt_ops(register_state: &mut RegisterState) -> Vec<MemwOperation> {
         let (old_val, old_ts) = register_state.read(0);
         let old_value = pack_register_value(old_val);
         let old_timestamps = [old_ts, old_ts, 0, 0, 0, 0, 0, 0];
-        let memw_op = MemwOperation::new(true, 0, [0; 8], ts, 2, false)
-            .with_old(old_value, old_timestamps);
+        let memw_op =
+            MemwOperation::new(true, 0, [0; 8], ts, 2, false).with_old(old_value, old_timestamps);
         ops.push(memw_op);
         // x0 value stays 0, but update timestamp directly (write() guards x0).
         register_state.regs[0] = (0, ts);
@@ -772,8 +772,8 @@ fn collect_halt_ops(register_state: &mut RegisterState) -> Vec<MemwOperation> {
         let (old_index, old_ts) = register_state.read_index();
         let old_value = [old_index as u64, 0, 0, 0, 0, 0, 0, 0];
         let old_timestamps = [old_ts, 0, 0, 0, 0, 0, 0, 0];
-        let memw_op = MemwOperation::new(true, 508, [0; 8], ts, 1, false)
-            .with_old(old_value, old_timestamps);
+        let memw_op =
+            MemwOperation::new(true, 508, [0; 8], ts, 1, false).with_old(old_value, old_timestamps);
         ops.push(memw_op);
         register_state.write_index(0, ts);
     }
@@ -1985,10 +1985,11 @@ impl Traces {
         use super::mul::cols::NUM_COLUMNS as MUL_COLS;
         use super::page::NUM_PREPROCESSED_COLS as PAGE_PREPROCESSED;
         use super::page::cols::NUM_COLUMNS as PAGE_COLS;
-        use super::register::NUM_PREPROCESSED_COLS as REGISTER_PREPROCESSED;
-        use super::register::cols::NUM_COLUMNS as REGISTER_COLS;
         use super::shift::cols::NUM_COLUMNS as SHIFT_COLS;
 
+        // NOTE: REGISTER table is no longer materialized in `Traces` — its bus
+        // contributions are computed verifier-side in `compute_register_bus_offset`.
+
         let Traces {
             cpus,
             bitwise,
@@ -2001,7 +2002,6 @@ impl Traces {
             muls,
             dvrms,
             pages,
-            register,
             branches,
             halt,
             commit,
@@ -2042,7 +2042,6 @@ impl Traces {
         }
         total += (halt.num_rows() * HALT_COLS) as u64;
         total += (commit.num_rows() * COMMIT_COLS) as u64;
-        total += (register.num_rows() * (REGISTER_COLS - REGISTER_PREPROCESSED)) as u64;
         for t in pages {
             total += (t.num_rows() * (PAGE_COLS - PAGE_PREPROCESSED)) as u64;
         }
@@ -2077,7 +2076,6 @@ impl Traces {
         let n_branch = aux_cols(super::branch::bus_interactions().len());
         let n_halt = aux_cols(super::halt::bus_interactions().len());
         let n_commit = aux_cols(super::commit::bus_interactions().len());
-        let n_register = aux_cols(super::register::bus_interactions().len());
         // page::bus_interactions count is constant regardless of page_base.
         let n_page = aux_cols(super::page::bus_interactions(0).len());
         let n_memw_r = aux_cols(super::memw_register::bus_interactions().len());
@@ -2094,7 +2092,6 @@ impl Traces {
             muls,
             dvrms,
             pages,
-            register,
             branches,
             halt,
             commit,
@@ -2135,7 +2132,6 @@ impl Traces {
         }
         total += (halt.num_rows() * n_halt) as u64;
         total += (commit.num_rows() * n_commit) as u64;
-        total += (register.num_rows() * n_register) as u64;
         for t in pages {
             total += (t.num_rows() * n_page) as u64;
         }

prover/src/tests/prove_elfs_tests.rs

@@ -1042,7 +1042,10 @@ fn test_debug_memory_bus_tokens() {
     println!("After MEMW: total_sum = {}", total_sum);
 
     // REGISTER tokens are now verifier-computed (not in trace).
-    println!("After MEMW (REGISTER eliminated): total_sum = {}", total_sum);
+    println!(
+        "After MEMW (REGISTER eliminated): total_sum = {}",
+        total_sum
+    );
     println!(
         "Bus {} (should be ~0 if balanced)",
         if total_sum.abs() < 1e-10 {