perf(stark): skip fixed 0/1 muls in LogUp fingerprint accumulation (#696)

* perf(stark): skip fixed 0/1 muls in LogUp fingerprint accumulation

In the fingerprint hot loop (prover aux-build + constraint-eval + verifier):

- Bus-id term: alpha_powers[0] = alpha^0 = 1, so embed the bus id into the
  extension field directly instead of multiplying by 1 (drops one F*E mul
  per interaction per row, hoisted out of the row loop on the aux path).
- Fixed-zero bus elements (the ~235 constant(0) used for bus-width padding)
  contribute nothing: skip the F*E multiply + accumulate entirely. Variable
  elements that happen to be zero on a row also benefit.

Value-identical (field addition is exactly associative): stark lib 128/128
(default + parallel), prover bus/logup tests pass, clippy clean.
Net effect on prove time is what we want to measure on the 32-core bench.

* docs(stark): align fingerprint comments with the α⁰=1 optimization

- compute_fingerprint_from_step: drop the vestigial *α^0 from the doc
  formula so it mirrors the code (and matches docs/cryptography/lookup.md
  and spec/logup.typ).
- accumulate_fingerprint{,_from_step}: the zero-skip also covers variable
  elements that are zero on a row, not just the constant(0) padding —
  reword the inline comments to say so.

---------

Co-authored-by: Mauro Toscano <12560266+MauroToscano@users.noreply.github.com>
Co-authored-by: MauroFab <maurotoscano2@gmail.com>

Author: diegokingston

crypto/stark/src/lookup.rs

@@ -668,7 +668,13 @@ impl BusValue {
                         }
                     }
                 }
-                *acc += &result * &alpha_powers[alpha_offset];
+                // Bus elements that are zero on this row contribute nothing — skip the
+                // F×E multiply. (Covers the constant(0) bus-width padding plus any
+                // variable element that is zero on this row; α⁰ = 1 covers the bus-id
+                // term separately.)
+                if result != FieldElement::<F>::zero() {
+                    *acc += &result * &alpha_powers[alpha_offset];
+                }
                 1
             }
         }
@@ -778,7 +784,12 @@ impl BusValue {
                         }
                     }
                 }
-                *acc += result * &alpha_powers[alpha_offset];
+                // Bus elements that are zero on this row contribute nothing — skip the
+                // F×E multiply. (Covers the constant(0) bus-width padding plus any
+                // variable element that is zero on this row.)
+                if result != FieldElement::<A>::zero() {
+                    *acc += result * &alpha_powers[alpha_offset];
+                }
                 1
             }
         }
@@ -1483,11 +1494,10 @@ where
         // fp[k*chunk_len + i] = interaction k at row chunk_start+i.
         let mut fingerprints: Vec<FieldElement<E>> = Vec::with_capacity(n * chunk_len);
         for interaction in interactions.iter() {
+            // α⁰ = 1: the bus-id term needs no multiply — embed it into E once.
+            let bus_id_e = FieldElement::<E>::from(interaction.bus_id);
             for row in chunk_start..chunk_start + chunk_len {
-                // alpha_powers[0] is always 1, so the bus_id term is just the
-                // embedded bus id — skip the base×ext multiply and build the
-                // extension element straight from the bus id.
-                let mut lc = FieldElement::<E>::from(interaction.bus_id);
+                let mut lc = bus_id_e.clone();
                 let mut alpha_offset = 1;
                 for bv in &interaction.values {
                     alpha_offset += bv.accumulate_fingerprint(
@@ -1675,17 +1685,15 @@ fn compute_multiplicity_from_step<A: IsSubFieldOf<B>, B: IsField>(
 
 /// Computes the fingerprint for an interaction from a `TableView`.
 ///
-/// Returns `z - (bus_id*α^0 + v[0]*α^1 + v[1]*α^2 + ...)`
+/// Returns `z - (bus_id + α·v[0] + α²·v[1] + ...)`
 fn compute_fingerprint_from_step<A: IsSubFieldOf<B>, B: IsField>(
     step: &TableView<A, B>,
     interaction: &BusInteraction,
     z: &FieldElement<B>,
     alpha_powers: &[FieldElement<B>],
     shifts: &PackingShifts<A>,
 ) -> FieldElement<B> {
-    // alpha_powers[0] is always 1, so the bus_id term is just the embedded bus
-    // id — skip the base×ext multiply and build the extension element straight
-    // from the bus id.
+    // α⁰ = 1: the bus-id term needs no multiply — embed it into B directly.
     let mut linear_combination = FieldElement::<B>::from(interaction.bus_id);
     let mut alpha_idx = 1;
     for bv in &interaction.values {