perf: use batch inversion for verifier bus offset computation

Author: diegokingston

prover/src/lib.rs

@@ -440,15 +440,19 @@ pub(crate) fn compute_commit_bus_offset(
     let bus_id = FieldElement::<E>::from(BusId::Commit as u64);
     let alpha_sq = alpha * alpha;
 
-    let mut total = FieldElement::<E>::zero();
-    for (i, &value) in public_output.iter().enumerate() {
-        let linear_combination = bus_id
-            + (FieldElement::<E>::from(i as u64) * alpha)
-            + (FieldElement::<E>::from(value as u64) * alpha_sq);
-        let fingerprint = z - linear_combination;
-        total += fingerprint.inv().ok()?;
-    }
-    Some(total)
+    let mut fingerprints: Vec<FieldElement<E>> = public_output
+        .iter()
+        .enumerate()
+        .map(|(i, &value)| {
+            let lc = &bus_id
+                + &(FieldElement::<E>::from(i as u64) * alpha)
+                + &(FieldElement::<E>::from(value as u64) * &alpha_sq);
+            z - &lc
+        })
+        .collect();
+
+    FieldElement::inplace_batch_inverse(&mut fingerprints).ok()?;
+    Some(fingerprints.iter().fold(FieldElement::zero(), |acc, inv| acc + inv))
 }
 
 /// Compute the bus balance offset for the REGISTER table on the Memory bus.
@@ -497,42 +501,49 @@ pub(crate) fn compute_register_bus_offset(
     let ts_hi = FieldElement::<E>::from(0xFFFF_FFFFu64);
     let fini_ts_contrib = &(&ts_lo * &alpha4) + &(&ts_hi * &alpha5);
 
-    let mut total = FieldElement::<E>::zero();
-
     let addr_list = register::register_word_address_list();
+    let n = addr_list.len();
+
+    // Build all 2*n fingerprints (init + fini per address), then batch-invert.
+    // signs[i] = -1 for init (receiver), +1 for fini (sender).
+    let mut fingerprints: Vec<FieldElement<E>> = Vec::with_capacity(2 * n);
+    let mut signs: Vec<i8> = Vec::with_capacity(2 * n);
 
     for &addr in &addr_list {
-        let addr_fe = FieldElement::<E>::from(addr);
-        let addr_contrib = &addr_fe * &alpha2;
+        let addr_contrib = FieldElement::<E>::from(addr) * &alpha2;
 
-        // Init value: deterministic from entry_point
         let init_value = register::init_value_for_address(addr, entry_point);
-
-        // Fini value: deterministic after HALT finalization
-        // HALT writes 0 to all registers except x255 which gets value=1.
-        // x255 lo word (addr 510) → fini=1, x255 hi word (addr 511) → fini=0.
         let fini_value: u32 = if addr == 510 { 1 } else { 0 };
 
-        // REG-C1 (receiver, sign=-1): init token with ts=0
-        // lc = base_lc + addr * α^2 + 0*α^3 + 0*α^4 + 0*α^5 + init_value * α^6
+        // REG-C1 (receiver): init token with ts=0
         let lc_init = &base_lc
             + &addr_contrib
             + &(FieldElement::<E>::from(init_value as u64) * &alpha6);
-        let fp_init = z - &lc_init;
-        let inv_init = fp_init.inv().ok()?;
-        total = total - inv_init; // receiver: -1/fp
+        fingerprints.push(z - &lc_init);
+        signs.push(-1);
 
-        // REG-C2 (sender, sign=+1): fini token with ts=MAX
-        // lc = base_lc + addr * α^2 + 0*α^3 + MAX_LO*α^4 + MAX_HI*α^5 + fini_value * α^6
+        // REG-C2 (sender): fini token with ts=MAX
         let lc_fini = &base_lc
             + &addr_contrib
             + &fini_ts_contrib
             + &(FieldElement::<E>::from(fini_value as u64) * &alpha6);
-        let fp_fini = z - &lc_fini;
-        let inv_fini = fp_fini.inv().ok()?;
-        total = total + inv_fini; // sender: +1/fp
+        fingerprints.push(z - &lc_fini);
+        signs.push(1);
     }
 
+    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
+            }
+        });
+
     Some(total)
 }