No Coeffs in Trace

crates/prover/src/constraint_framework/component.rs

@@ -288,13 +288,6 @@ impl<E: FrameworkEval + Sync> ComponentProver<SimdBackend> for FrameworkComponen
         let eval_domain = CanonicCoset::new(self.max_constraint_log_degree_bound()).circle_domain();
         let trace_domain = CanonicCoset::new(self.eval.log_size());
 
-        let mut component_polys = trace.polys.sub_tree(&self.trace_locations);
-        component_polys[PREPROCESSED_TRACE_IDX] = self
-            .preprocessed_column_indices
-            .iter()
-            .map(|idx| &trace.polys[PREPROCESSED_TRACE_IDX][*idx])
-            .collect();
-
         let mut component_evals = trace.evals.sub_tree(&self.trace_locations);
         component_evals[PREPROCESSED_TRACE_IDX] = self
             .preprocessed_column_indices
@@ -314,9 +307,15 @@ impl<E: FrameworkEval + Sync> ComponentProver<SimdBackend> for FrameworkComponen
         > = if need_to_extend {
             let _span = span!(Level::INFO, "Extension").entered();
             let twiddles = SimdBackend::precompute_twiddles(eval_domain.half_coset);
-            component_polys
-                .as_cols_ref()
-                .map_cols(|col| Cow::Owned(col.evaluate_with_twiddles(eval_domain, &twiddles)))
+            component_evals.as_cols_ref().map_cols(|col| {
+                Cow::Owned(
+                    (**col)
+                        .clone()
+                        .interpolate()
+                        .reduce_poly()
+                        .evaluate_with_twiddles(eval_domain, &twiddles),
+                )
+            })
         } else {
             component_evals.clone().map_cols(|c| Cow::Borrowed(*c))
         };

crates/prover/src/core/air/mod.rs

@@ -6,7 +6,7 @@ use super::circle::CirclePoint;
 use super::fields::m31::BaseField;
 use super::fields::qm31::SecureField;
 use super::pcs::TreeVec;
-use super::poly::circle::{CircleEvaluation, CirclePoly};
+use super::poly::circle::CircleEvaluation;
 use super::poly::BitReversedOrder;
 use super::ColumnVec;
 
@@ -68,10 +68,8 @@ pub trait ComponentProver<B: Backend>: Component {
 
 /// The set of polynomials that make up the trace.
 ///
-/// Each polynomial is stored both in a coefficients, and evaluations form (for efficiency)
+/// Each polynomial is stored only in evaluations form (for efficiency)
 pub struct Trace<'a, B: Backend> {
-    /// Polynomials for each column.
-    pub polys: TreeVec<ColumnVec<&'a CirclePoly<B>>>,
     /// Evaluations for each column (evaluated on their commitment domains).
     pub evals: TreeVec<ColumnVec<&'a CircleEvaluation<B, BaseField, BitReversedOrder>>>,
 }

crates/prover/src/core/pcs/prover.rs

@@ -79,12 +79,6 @@ impl<'a, B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentSchemeProver<'a,
         self.trees.as_ref().map(|tree| tree.commitment.root())
     }
 
-    pub fn polynomials(&self) -> TreeVec<ColumnVec<&CirclePoly<B>>> {
-        self.trees
-            .as_ref()
-            .map(|tree| tree.polynomials.iter().collect())
-    }
-
     pub fn evaluations(
         &self,
     ) -> TreeVec<ColumnVec<&CircleEvaluation<B, BaseField, BitReversedOrder>>> {
@@ -94,9 +88,8 @@ impl<'a, B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentSchemeProver<'a,
     }
 
     pub fn trace(&self) -> Trace<'_, B> {
-        let polys = self.polynomials();
         let evals = self.evaluations();
-        Trace { polys, evals }
+        Trace { evals }
     }
 
     pub fn build_weights_hash_map(
@@ -244,7 +237,6 @@ impl<B: BackendForChannel<MC>, MC: MerkleChannel> TreeBuilder<'_, '_, B, MC> {
 /// Prover data for a single commitment tree in a commitment scheme. The commitment scheme allows to
 /// commit on a set of polynomials at a time. This corresponds to such a set.
 pub struct CommitmentTreeProver<B: BackendForChannel<MC>, MC: MerkleChannel> {
-    pub polynomials: ColumnVec<CirclePoly<B>>,
     pub evaluations: ColumnVec<CircleEvaluation<B, BaseField, BitReversedOrder>>,
     pub commitment: MerkleProver<B, MC::H>,
 }
@@ -269,7 +261,6 @@ impl<B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentTreeProver<B, MC> {
         MC::mix_root(channel, tree.root());
 
         CommitmentTreeProver {
-            polynomials,
             evaluations,
             commitment: tree,
         }
@@ -290,7 +281,6 @@ impl<B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentTreeProver<B, MC> {
         MC::mix_root(channel, tree.root());
 
         CommitmentTreeProver {
-            polynomials,
             evaluations,
             commitment: tree,
         }

crates/prover/src/core/poly/circle/poly.rs

@@ -1,3 +1,5 @@
+use num_traits::Zero;
+
 use super::{CircleDomain, CircleEvaluation, PolyOps};
 use crate::core::backend::{Col, Column, ColumnOps};
 use crate::core::circle::CirclePoint;
@@ -63,6 +65,27 @@ impl<B: PolyOps> CirclePoly<B> {
     ) -> CircleEvaluation<B, BaseField, BitReversedOrder> {
         B::evaluate(self, domain, twiddles)
     }
+
+    /// Reduces the polynomial to a minimal degree polynomial that evaluates to the same values.
+    pub fn reduce_poly(self) -> Self {
+        let coeffs = self.coeffs.clone();
+        let mut new_log_size = coeffs.len().ilog2();
+        while coeffs.at(1 << new_log_size - 1) == BaseField::zero() {
+            if new_log_size == 1
+                || (((1 << (new_log_size - 1))..(1 << new_log_size))
+                    .any(|i| coeffs.at(i) != BaseField::zero()))
+            {
+                break;
+            }
+            new_log_size -= 1;
+        }
+        Self {
+            log_size: new_log_size,
+            coeffs: Col::<B, BaseField>::from_iter(
+                coeffs.to_cpu()[..1 << new_log_size].iter().copied(),
+            ),
+        }
+    }
 }
 
 #[cfg(test)]

crates/prover/src/core/prover/mod.rs

@@ -30,7 +30,7 @@ pub fn prove<B: BackendForChannel<MC>, MC: MerkleChannel>(
     mut commitment_scheme: CommitmentSchemeProver<'_, B, MC>,
 ) -> Result<StarkProof<MC::H>, ProvingError> {
     let n_preprocessed_columns = commitment_scheme.trees[PREPROCESSED_TRACE_IDX]
-        .polynomials
+        .evaluations
         .len();
     let component_provers = ComponentProvers {
         components: components.to_vec(),

crates/prover/src/examples/blake/air.rs

@@ -483,9 +483,9 @@ where
 
     assert_eq!(
         commitment_scheme
-            .polynomials()
+            .evaluations()
             .as_cols_ref()
-            .map_cols(|c| c.log_size())
+            .map_cols(|c| { (*c).clone().interpolate().log_size() })
             .0,
         stmt0.log_sizes().0
     );

crates/prover/src/examples/plonk/mod.rs

@@ -5,8 +5,7 @@ use tracing::{span, Level};
 use crate::constraint_framework::logup::{LogupTraceGenerator, LookupElements};
 use crate::constraint_framework::preprocessed_columns::PreProcessedColumnId;
 use crate::constraint_framework::{
-    assert_constraints_on_polys, relation, EvalAtRow, FrameworkComponent, FrameworkEval,
-    RelationEntry, TraceLocationAllocator,
+    relation, EvalAtRow, FrameworkComponent, FrameworkEval, RelationEntry, TraceLocationAllocator,
 };
 use crate::core::backend::simd::column::BaseColumn;
 use crate::core::backend::simd::m31::LOG_N_LANES;
@@ -242,20 +241,20 @@ pub fn prove_fibonacci_plonk(
         claimed_sum,
     );
 
-    // Sanity check. Remove for production.
-    let trace_polys = commitment_scheme
-        .trees
-        .as_ref()
-        .map(|t| t.polynomials.iter().cloned().collect_vec());
-    let component_eval = component.clone();
-    assert_constraints_on_polys(
-        &trace_polys,
-        CanonicCoset::new(log_n_rows),
-        |assert_eval| {
-            component_eval.evaluate(assert_eval);
-        },
-        claimed_sum,
-    );
+    // // Sanity check. Remove for production.
+    // let trace_polys = commitment_scheme
+    //     .trees
+    //     .as_ref()
+    //     .map(|t| t.polynomials.iter().cloned().collect_vec());
+    // let component_eval = component.clone();
+    // assert_constraints_on_polys(
+    //     &trace_polys,
+    //     CanonicCoset::new(log_n_rows),
+    //     |assert_eval| {
+    //         component_eval.evaluate(assert_eval);
+    //     },
+    //     claimed_sum,
+    // );
 
     let proof = prove(&[&component], channel, commitment_scheme).unwrap();