fix: resolve clippy warnings and use F×E mixed arithmetic in bus offset computation

Author: diegokingston

prover/src/lib.rs

@@ -437,17 +437,18 @@ pub(crate) fn compute_commit_bus_offset(
         return Some(FieldElement::zero());
     }
 
-    let bus_id = FieldElement::<E>::from(BusId::Commit as u64);
     let alpha_sq = alpha * alpha;
-
+    let bus_id = FieldElement::<F>::from(BusId::Commit as u64);
+    // Negate once: fingerprint = z - lc = -(lc - z) but we compute z - lc directly
+    // by precomputing z_minus_bus = z - bus_id (F×E mixed subtraction)
+    let z_minus_bus = z - bus_id * FieldElement::<E>::one();
     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
+            let idx = FieldElement::<F>::from(i as u64);
+            let val = FieldElement::<F>::from(value as u64);
+            z_minus_bus - idx * alpha - val * alpha_sq
         })
         .collect();
 
@@ -486,48 +487,43 @@ pub(crate) fn compute_register_bus_offset(
 ) -> Option<FieldElement<E>> {
     let bus_id = FieldElement::<E>::from(BusId::Memory as u64);
     let alpha2 = alpha * alpha;
-    let alpha3 = &alpha2 * alpha;
-    let alpha4 = &alpha3 * alpha;
-    let alpha5 = &alpha4 * alpha;
-    let alpha6 = &alpha5 * alpha;
+    let alpha3 = alpha2 * alpha;
+    let alpha4 = alpha3 * alpha;
+    let alpha5 = alpha4 * alpha;
+    let alpha6 = alpha5 * alpha;
 
-    // Precompute constants that are the same for all addresses
-    let is_register = FieldElement::<E>::one(); // is_register = 1
-    // addr_hi = 0, contributes nothing
-    let base_lc = &bus_id + &(&is_register * alpha);
+    // base_lc = BusId::Memory + 1*α (is_register=1, addr_hi=0 contributes nothing)
+    let base_lc = bus_id + *alpha;
 
     // Fini timestamp: ts = u64::MAX = 0xFFFFFFFF_FFFFFFFF
-    let ts_lo = FieldElement::<E>::from(0xFFFF_FFFFu64);
-    let ts_hi = FieldElement::<E>::from(0xFFFF_FFFFu64);
-    let fini_ts_contrib = &(&ts_lo * &alpha4) + &(&ts_hi * &alpha5);
+    let ts_max = FieldElement::<F>::from(0xFFFF_FFFFu64);
+    let fini_ts_contrib = ts_max * (alpha4 + alpha5);
 
     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_contrib = FieldElement::<E>::from(addr) * &alpha2;
+        let addr_fe = FieldElement::<F>::from(addr);
+        let addr_contrib = addr_fe * alpha2;
 
         let init_value = register::init_value_for_address(addr, entry_point);
         let fini_value: u32 = if addr == 510 { 1 } else { 0 };
 
+        let init_fe = FieldElement::<F>::from(init_value as u64);
+        let fini_fe = FieldElement::<F>::from(fini_value as u64);
+
         // REG-C1 (receiver): init token with ts=0
-        let lc_init = &base_lc
-            + &addr_contrib
-            + &(FieldElement::<E>::from(init_value as u64) * &alpha6);
-        fingerprints.push(z - &lc_init);
+        let lc_init = base_lc + addr_contrib + init_fe * alpha6;
+        fingerprints.push(z - lc_init);
         signs.push(-1);
 
         // 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);
-        fingerprints.push(z - &lc_fini);
+        let lc_fini = base_lc + addr_contrib + fini_ts_contrib + fini_fe * alpha6;
+        fingerprints.push(z - lc_fini);
         signs.push(1);
     }