Evaluation oods once (#576)

src/core/air/air_ext.rs

@@ -1,7 +1,6 @@
 use std::iter::zip;
 
 use itertools::Itertools;
-use tracing::{span, Level};
 
 use super::accumulation::{DomainEvaluationAccumulator, PointEvaluationAccumulator};
 use super::{Air, ComponentTrace};
@@ -47,25 +46,6 @@ pub trait AirExt<B: Backend>: Air<B> {
         accumulator.finalize()
     }
 
-    fn mask_points_and_values(
-        &self,
-        point: CirclePoint<SecureField>,
-        component_traces: &[ComponentTrace<'_, B>],
-    ) -> (
-        ComponentVec<Vec<CirclePoint<SecureField>>>,
-        ComponentVec<Vec<SecureField>>,
-    ) {
-        let _span = span!(Level::INFO, "Evaluate columns out of domain").entered();
-        let mut component_points = ComponentVec(Vec::new());
-        let mut component_values = ComponentVec(Vec::new());
-        zip(self.components(), component_traces).for_each(|(component, trace)| {
-            let (points, values) = component.mask_points_and_values(point, trace);
-            component_points.push(points);
-            component_values.push(values);
-        });
-        (component_points, component_values)
-    }
-
     fn mask_points(
         &self,
         point: CirclePoint<SecureField>,

src/core/air/mod.rs

@@ -1,5 +1,3 @@
-use std::iter::zip;
-
 use self::accumulation::{DomainEvaluationAccumulator, PointEvaluationAccumulator};
 use super::backend::Backend;
 use super::circle::CirclePoint;
@@ -49,31 +47,6 @@ pub trait Component<B: Backend> {
         point: CirclePoint<SecureField>,
     ) -> ColumnVec<Vec<CirclePoint<SecureField>>>;
 
-    /// Calculates the mask points and evaluates them at each column.
-    /// The mask values are used to evaluate the composition polynomial at a certain point.
-    /// Returns two vectors with an entry for each column. Each entry holds the points/values
-    /// of the mask at that column.
-    fn mask_points_and_values(
-        &self,
-        point: CirclePoint<SecureField>,
-        trace: &ComponentTrace<'_, B>,
-    ) -> (
-        ColumnVec<Vec<CirclePoint<SecureField>>>,
-        ColumnVec<Vec<SecureField>>,
-    ) {
-        let points = self.mask_points(point);
-        let values = zip(&points, &trace.polys)
-            .map(|(col_points, col)| {
-                col_points
-                    .iter()
-                    .map(|point| col.eval_at_point(*point))
-                    .collect()
-            })
-            .collect();
-
-        (points, values)
-    }
-
     /// Evaluates the constraint quotients combination of the component, given the mask values.
     fn evaluate_constraint_quotients_at_point(
         &self,

src/core/commitment_scheme/prover.rs

@@ -76,7 +76,8 @@ impl<B: Backend + MerkleOps<MerkleHasher>> CommitmentSchemeProver<B> {
         channel: &mut ProofChannel,
         twiddles: &TwiddleTree<B>,
     ) -> CommitmentSchemeProof {
-        // Evaluate polynomials on samples points.
+        // Evaluate polynomials on open points.
+        let span = span!(Level::INFO, "Evaluate columns out of domain").entered();
         let samples = self
             .polynomials()
             .zip_cols(&sampled_points)
@@ -89,6 +90,7 @@ impl<B: Backend + MerkleOps<MerkleHasher>> CommitmentSchemeProver<B> {
                     })
                     .collect_vec()
             });
+        span.exit();
         let sampled_values = samples
             .as_cols_ref()
             .map_cols(|x| x.iter().map(|o| o.value).collect());

src/core/prover/mod.rs

@@ -121,10 +121,7 @@ pub fn prove<B: Backend + MerkleOps<MerkleHasher>>(
     // Second tree - composition polynomial.
     sample_points.push(vec![vec![oods_point]; 4]);
 
-    // TODO(spapini): Precompute twiddles outside.
-    let twiddles = B::precompute_twiddles(
-        CanonicCoset::new(composition_polynomial_log_degree_bound + 1).half_coset(),
-    );
+    // Prove the trace and composition OODS values, and retrieve them.
     let commitment_scheme_proof = commitment_scheme.prove_values(sample_points, channel, &twiddles);
 
     // Evaluate composition polynomial at OODS point and check that it matches the trace OODS

src/examples/fibonacci/mod.rs

@@ -110,6 +110,7 @@ impl MultiFibonacci {
 #[cfg(test)]
 mod tests {
     use std::assert_matches::assert_matches;
+    use std::iter::zip;
 
     use itertools::Itertools;
     use num_traits::One;
@@ -159,10 +160,16 @@ mod tests {
         // what we expect.
         let point = CirclePoint::<SecureField>::get_point(98989892);
 
-        let (_, mask_values) = fib
-            .air
-            .component
-            .mask_points_and_values(point, &component_traces[0]);
+        let points = fib.air.mask_points(point);
+        let mask_values = zip(&component_traces[0].polys, &points[0])
+            .map(|(poly, points)| {
+                points
+                    .iter()
+                    .map(|point| poly.eval_at_point(*point))
+                    .collect_vec()
+            })
+            .collect_vec();
+
         let mut evaluation_accumulator = PointEvaluationAccumulator::new(random_coeff);
         fib.air.component.evaluate_constraint_quotients_at_point(
             point,

src/examples/wide_fibonacci/constraint_eval.rs

@@ -41,11 +41,7 @@ impl Component<CPUBackend> for WideFibComponent {
     ) {
         let max_constraint_degree = Component::<CPUBackend>::max_constraint_log_degree_bound(self);
         let trace_eval_domain = CanonicCoset::new(max_constraint_degree).circle_domain();
-        let mut trace_evals = vec![];
-        for poly_index in 0..256 {
-            let poly = &trace.polys[poly_index];
-            trace_evals.push(poly.evaluate(trace_eval_domain));
-        }
+        let trace_evals = &trace.evals;
         let zero_domain = CanonicCoset::new(self.log_size).coset;
         let mut denoms = vec![];
         for point in trace_eval_domain.iter() {