feat(prover): add compiled constraint evaluator for CPU table

Eliminates 77 virtual dispatch calls per LDE row for the CPU table by
inlining all constraint computations. Uses F×E multiplication (3 base
muls) instead of to_extension() + E×E multiplication (6 base muls) for
the 66 native constraints that produce base-field results.

Changes:
- AIR trait: add evaluate_transitions_compiled() optional method
- AirWithBuses: add CompiledEvaluator trait + with_compiled_evaluator()
- Evaluator: try compiled path before virtual dispatch fallback
- lookup: add compute_fingerprint_raw/compute_multiplicity_raw helpers
- CpuCompiledEvaluator: inline all 66 native + 11 LogUp constraints

Author: diegokingston

crypto/stark/src/constraints/evaluator.rs

@@ -98,6 +98,33 @@ where
                     |(transition_buf, periodic_buf, frame), (i, boundary)| {
                         frame.fill_from_lde(lde_trace, i, offsets);
 
+                        // Try compiled path: bypasses virtual dispatch + to_extension()
+                        // by computing the weighted sum directly with F×E multiplication.
+                        // Requires at least 2 evaluation steps (current + next row).
+                        if num_offsets >= 2 {
+                            let step0 = frame.get_evaluation_step(0);
+                            let step1 = frame.get_evaluation_step(1);
+                            if let Some(compiled_sum) = air.evaluate_transitions_compiled(
+                                &step0.data[0],
+                                &step1.data[0],
+                                &step0.aux_data[0],
+                                &step1.aux_data[0],
+                                transition_coefficients,
+                                rap_challenges,
+                                &logup_alpha_powers,
+                                logup_table_offset,
+                            ) {
+                                // Compiled path already returns the weighted sum.
+                                // Apply zerofier (uniform fast path — CPU has uniform zerofier).
+                                let z = if is_uniform {
+                                    zerofier_data.get_uniform(i)
+                                } else {
+                                    zerofier_data.get(0, i)
+                                };
+                                return z * &compiled_sum + boundary;
+                            }
+                        }
+
                         for (j, col) in lde_periodic_columns.iter().enumerate() {
                             periodic_buf[j] = col[i].clone();
                         }
@@ -150,6 +177,30 @@ where
                 .map(|(i, boundary)| {
                     frame.fill_from_lde(lde_trace, i, offsets);
 
+                    // Try compiled path: bypasses virtual dispatch + to_extension()
+                    // Requires at least 2 evaluation steps (current + next row).
+                    if num_offsets >= 2 {
+                        let step0 = frame.get_evaluation_step(0);
+                        let step1 = frame.get_evaluation_step(1);
+                        if let Some(compiled_sum) = air.evaluate_transitions_compiled(
+                            &step0.data[0],
+                            &step1.data[0],
+                            &step0.aux_data[0],
+                            &step1.aux_data[0],
+                            transition_coefficients,
+                            rap_challenges,
+                            &logup_alpha_powers,
+                            logup_table_offset,
+                        ) {
+                            let z = if is_uniform {
+                                zerofier_data.get_uniform(i)
+                            } else {
+                                zerofier_data.get(0, i)
+                            };
+                            return z * &compiled_sum + boundary;
+                        }
+                    }
+
                     for (j, col) in lde_periodic_columns.iter().enumerate() {
                         periodic_buf[j] = col[i].clone();
                     }

crypto/stark/src/lookup.rs

@@ -778,6 +778,31 @@ impl BusValue {
     }
 }
 
+// =============================================================================
+// Compiled Constraint Evaluator
+// =============================================================================
+
+/// Trait for compiled constraint evaluation, bypassing virtual dispatch.
+///
+/// Implementors compute the weighted sum `sum_i beta_i * constraint_i(row)` directly,
+/// using F×E multiplication (3 base muls) instead of `to_extension()` + E×E (6 base muls).
+pub trait CompiledEvaluator<F: IsField, E: IsField>: Send + Sync {
+    /// Compute the weighted sum of ALL constraints (native + LogUp) for one LDE row.
+    ///
+    /// Must return the same value as the virtual-dispatch path to maintain soundness.
+    fn evaluate(
+        &self,
+        main_curr: &[FieldElement<F>],
+        main_next: &[FieldElement<F>],
+        aux_curr: &[FieldElement<E>],
+        aux_next: &[FieldElement<E>],
+        transition_coefficients: &[FieldElement<E>],
+        rap_challenges: &[FieldElement<E>],
+        logup_alpha_powers: &[FieldElement<E>],
+        logup_table_offset: &FieldElement<E>,
+    ) -> FieldElement<E>;
+}
+
 // =============================================================================
 // AirWithBuses
 // =============================================================================
@@ -804,6 +829,8 @@ pub struct AirWithBuses<
     /// Maximum number of bus elements across all interactions.
     /// Used to compute the correct number of alpha powers.
     max_bus_elements: usize,
+    /// Optional compiled evaluator: bypasses virtual dispatch in constraint evaluation hot loop.
+    compiled_evaluator: Option<Box<dyn CompiledEvaluator<F, E>>>,
 }
 
 impl<
@@ -896,6 +923,7 @@ impl<
             num_precomputed_cols: None,
             name: None,
             max_bus_elements,
+            compiled_evaluator: None,
         }
     }
 
@@ -933,6 +961,19 @@ impl<
         self.name = Some(name.to_string());
         self
     }
+
+    /// Attach a compiled constraint evaluator that bypasses virtual dispatch.
+    ///
+    /// When set, the evaluator's hot loop calls this instead of iterating over
+    /// `transition_constraints` with dynamic dispatch. The compiled evaluator
+    /// must compute the same weighted sum as the virtual-dispatch path.
+    pub fn with_compiled_evaluator(
+        mut self,
+        evaluator: Box<dyn CompiledEvaluator<F, E>>,
+    ) -> Self {
+        self.compiled_evaluator = Some(evaluator);
+        self
+    }
 }
 
 impl<F, E, B, PI> crate::traits::AIR for AirWithBuses<F, E, B, PI>
@@ -996,6 +1037,31 @@ where
         &self.transition_constraints
     }
 
+    fn evaluate_transitions_compiled(
+        &self,
+        main_curr: &[FieldElement<Self::Field>],
+        main_next: &[FieldElement<Self::Field>],
+        aux_curr: &[FieldElement<Self::FieldExtension>],
+        aux_next: &[FieldElement<Self::FieldExtension>],
+        transition_coefficients: &[FieldElement<Self::FieldExtension>],
+        rap_challenges: &[FieldElement<Self::FieldExtension>],
+        logup_alpha_powers: &[FieldElement<Self::FieldExtension>],
+        logup_table_offset: &FieldElement<Self::FieldExtension>,
+    ) -> Option<FieldElement<Self::FieldExtension>> {
+        self.compiled_evaluator.as_ref().map(|ce| {
+            ce.evaluate(
+                main_curr,
+                main_next,
+                aux_curr,
+                aux_next,
+                transition_coefficients,
+                rap_challenges,
+                logup_alpha_powers,
+                logup_table_offset,
+            )
+        })
+    }
+
     fn build_auxiliary_trace(
         &self,
         trace: &mut TraceTable<F, E>,
@@ -1849,6 +1915,105 @@ fn compute_fingerprint_from_step<A: IsSubFieldOf<B>, B: IsField>(
     z - &linear_combination
 }
 
+/// Computes multiplicity from a raw main trace slice (compiled evaluator path).
+pub fn compute_multiplicity_raw<F: IsField>(
+    main: &[FieldElement<F>],
+    multiplicity: &Multiplicity,
+) -> FieldElement<F> {
+    match multiplicity {
+        Multiplicity::One => FieldElement::<F>::one(),
+        Multiplicity::Column(col) => main[*col].clone(),
+        Multiplicity::Sum(col_a, col_b) => &main[*col_a] + &main[*col_b],
+        Multiplicity::Negated(col) => FieldElement::<F>::one() - &main[*col],
+        Multiplicity::Diff(col_a, col_b) => &main[*col_a] - &main[*col_b],
+        Multiplicity::Sum3(col_a, col_b, col_c) => &main[*col_a] + &main[*col_b] + &main[*col_c],
+        Multiplicity::Linear(terms) => {
+            let mut result = FieldElement::<F>::zero();
+            for term in terms {
+                match term {
+                    LinearTerm::Column {
+                        coefficient,
+                        column,
+                    } => {
+                        let coeff = FieldElement::<F>::from(*coefficient);
+                        result += &main[*column] * coeff;
+                    }
+                    LinearTerm::ColumnUnsigned {
+                        coefficient,
+                        column,
+                    } => {
+                        let coeff = FieldElement::<F>::from(*coefficient);
+                        result += &main[*column] * coeff;
+                    }
+                    LinearTerm::Constant(value) => {
+                        result += FieldElement::<F>::from(*value);
+                    }
+                }
+            }
+            result
+        }
+    }
+}
+
+/// Computes fingerprint from a raw main trace slice (compiled evaluator path).
+///
+/// Returns `z - (bus_id*alpha^0 + v[0]*alpha^1 + ...)`
+pub fn compute_fingerprint_raw<F: IsSubFieldOf<E>, E: IsField>(
+    main: &[FieldElement<F>],
+    interaction: &BusInteraction,
+    z: &FieldElement<E>,
+    alpha_powers: &[FieldElement<E>],
+    shifts: &PackingShifts<F>,
+) -> FieldElement<E> {
+    let bus_id_f: FieldElement<F> = FieldElement::from(interaction.bus_id);
+    let mut linear_combination = bus_id_f * &alpha_powers[0];
+    let mut alpha_idx = 1;
+    for bv in &interaction.values {
+        match bv {
+            BusValue::Packed {
+                start_column,
+                packing,
+            } => {
+                alpha_idx += packing.accumulate_fingerprint_with(
+                    *start_column,
+                    |col| &main[col],
+                    alpha_powers,
+                    alpha_idx,
+                    &mut linear_combination,
+                    shifts,
+                );
+            }
+            BusValue::Linear(terms) => {
+                let mut result = FieldElement::<F>::zero();
+                for term in terms {
+                    match term {
+                        LinearTerm::Column {
+                            coefficient,
+                            column,
+                        } => {
+                            let coeff = FieldElement::<F>::from(*coefficient);
+                            result += &main[*column] * coeff;
+                        }
+                        LinearTerm::ColumnUnsigned {
+                            coefficient,
+                            column,
+                        } => {
+                            let coeff = FieldElement::<F>::from(*coefficient);
+                            result += &main[*column] * coeff;
+                        }
+                        LinearTerm::Constant(value) => {
+                            result += FieldElement::<F>::from(*value);
+                        }
+                    }
+                }
+                linear_combination += result * &alpha_powers[alpha_idx];
+                alpha_idx += 1;
+            }
+        }
+    }
+    z - &linear_combination
+}
+
 /// Constraint for a batched pair of interactions sharing one aux column.
 ///
 /// Verifies: `c = m_a/fp_a + m_b/fp_b` where signs are baked into m_a, m_b.

crypto/stark/src/traits.rs

@@ -306,6 +306,38 @@ pub trait AIR: Send + Sync {
         result
     }
 
+    /// Compiled constraint evaluation: computes the weighted sum
+    /// `sum_i beta_i * constraint_i(row)` directly, bypassing virtual dispatch.
+    /// Returns the pre-zerofier composition value for one LDE row.
+    ///
+    /// The key optimization is using F*E multiplication (3 base muls) for
+    /// base-field constraints instead of the `to_extension()` + E*E mul path
+    /// (embed + 6 base muls).
+    ///
+    /// Parameters:
+    /// - `main_curr`/`main_next`: raw column values at current and next LDE rows
+    /// - `aux_curr`/`aux_next`: extension-field column values (LogUp)
+    /// - `transition_coefficients`: random linear combination weights (one per constraint)
+    /// - `rap_challenges`: LogUp challenges `[z, alpha]`
+    /// - `logup_alpha_powers`: precomputed powers of alpha for fingerprint computation
+    /// - `logup_table_offset`: `L/N` per table for circular LogUp constraint
+    ///
+    /// Returns `Some(weighted_sum)` if compiled path is available, `None` to fall back.
+    #[allow(unused_variables)]
+    fn evaluate_transitions_compiled(
+        &self,
+        main_curr: &[FieldElement<Self::Field>],
+        main_next: &[FieldElement<Self::Field>],
+        aux_curr: &[FieldElement<Self::FieldExtension>],
+        aux_next: &[FieldElement<Self::FieldExtension>],
+        transition_coefficients: &[FieldElement<Self::FieldExtension>],
+        rap_challenges: &[FieldElement<Self::FieldExtension>],
+        logup_alpha_powers: &[FieldElement<Self::FieldExtension>],
+        logup_table_offset: &FieldElement<Self::FieldExtension>,
+    ) -> Option<FieldElement<Self::FieldExtension>> {
+        None
+    }
+
     fn transition_constraints(
         &self,
     ) -> &Vec<Box<dyn TransitionConstraint<Self::Field, Self::FieldExtension>>>;