Move SecureColumn

src/core/air/evaluation.rs

@@ -3,50 +3,13 @@
 //! Given a random alpha, the combined polynomial is defined as
 //!   f(p) = sum_i alpha^{N-1-i} u_i (P).
 use crate::core::backend::cpu::CPUCircleEvaluation;
-use crate::core::backend::{Backend, CPUBackend, Col, Column};
+use crate::core::backend::{Backend, CPUBackend};
 use crate::core::fields::m31::BaseField;
 use crate::core::fields::qm31::SecureField;
-use crate::core::fields::{ExtensionOf, FieldExpOps};
+use crate::core::fields::secure_column::SecureColumn;
+use crate::core::fields::FieldExpOps;
 use crate::core::poly::circle::{CanonicCoset, CirclePoly, SecureCirclePoly};
 use crate::core::poly::BitReversedOrder;
-use crate::core::utils::IteratorMutExt;
-
-pub const SECURE_EXTENSION_DEGREE: usize =
-    <SecureField as ExtensionOf<BaseField>>::EXTENSION_DEGREE;
-
-// TODO(spapini): find a better place for this
-pub struct SecureColumn<B: Backend> {
-    pub cols: [Col<B, BaseField>; SECURE_EXTENSION_DEGREE],
-}
-
-impl SecureColumn<CPUBackend> {
-    fn at(&self, index: usize) -> SecureField {
-        SecureField::from_m31_array(std::array::from_fn(|i| self.cols[i][index]))
-    }
-
-    fn set(&mut self, index: usize, value: SecureField) {
-        self.cols
-            .iter_mut()
-            .map(|c| &mut c[index])
-            .assign(value.to_m31_array());
-    }
-}
-
-impl<B: Backend> SecureColumn<B> {
-    pub fn zeros(len: usize) -> Self {
-        Self {
-            cols: std::array::from_fn(|_| Col::<B, BaseField>::zeros(len)),
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.cols[0].len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.cols[0].is_empty()
-    }
-}
 
 /// Accumulates evaluations of u_i(P0) at a single point.
 /// Computes f(P0), the combined polynomial at that point.
@@ -167,7 +130,7 @@ impl DomainEvaluationAccumulator<CPUBackend> {
             .skip(1)
         {
             let coeffs = SecureColumn {
-                cols: values.cols.map(|c| {
+                columns: values.columns.map(|c| {
                     CPUCircleEvaluation::<_, BitReversedOrder>::new(
                         CanonicCoset::new(log_size as u32).circle_domain(),
                         c,
@@ -185,7 +148,7 @@ impl DomainEvaluationAccumulator<CPUBackend> {
             }
         }
 
-        SecureCirclePoly(res_coeffs.cols.map(CirclePoly::new))
+        SecureCirclePoly(res_coeffs.columns.map(CirclePoly::new))
     }
 }
 

src/core/channel.rs

@@ -1,7 +1,8 @@
 use std::iter;
 
 use super::fields::m31::{BaseField, N_BYTES_FELT, P};
-use super::fields::qm31::{SecureField, SECURE_FIELD_EXTENSION_DEGREE};
+use super::fields::qm31::SecureField;
+use super::fields::secure_column::SECURE_EXTENSION_DEGREE;
 use super::fields::IntoSlice;
 use crate::commitment_scheme::blake2_hash::{Blake2sHash, Blake2sHasher};
 use crate::commitment_scheme::hasher::Hasher;
@@ -122,7 +123,7 @@ impl Channel for Blake2sChannel {
 
     fn draw_felt(&mut self) -> SecureField {
         let felts: [BaseField; FELTS_PER_HASH] = self.draw_base_felts();
-        SecureField::from_m31_array(felts[..SECURE_FIELD_EXTENSION_DEGREE].try_into().unwrap())
+        SecureField::from_m31_array(felts[..SECURE_EXTENSION_DEGREE].try_into().unwrap())
     }
 
     fn draw_felts(&mut self, n_felts: usize) -> Vec<SecureField> {

src/core/fields/mod.rs

@@ -10,6 +10,7 @@ use super::backend::ColumnOps;
 pub mod cm31;
 pub mod m31;
 pub mod qm31;
+pub mod secure_column;
 
 pub trait FieldOps<F: Field>: ColumnOps<F> {
     // TODO(Ohad): change to use a mutable slice.

src/core/fields/qm31.rs

@@ -8,7 +8,6 @@ use crate::core::fields::cm31::CM31;
 use crate::core::fields::m31::M31;
 use crate::{impl_extension_field, impl_field};
 
-pub const SECURE_FIELD_EXTENSION_DEGREE: usize = 4;
 pub const P4: u128 = 21267647892944572736998860269687930881; // (2 ** 31 - 1) ** 4
 pub const R: CM31 = CM31::from_u32_unchecked(2, 1);
 

src/core/fields/secure_column.rs

@@ -0,0 +1,41 @@
+use super::m31::BaseField;
+use super::qm31::SecureField;
+use super::ExtensionOf;
+use crate::core::backend::{Backend, CPUBackend, Col, Column};
+use crate::core::utils::IteratorMutExt;
+
+pub const SECURE_EXTENSION_DEGREE: usize =
+    <SecureField as ExtensionOf<BaseField>>::EXTENSION_DEGREE;
+
+/// An array of `SECURE_EXTENSION_DEGREE` base field columns, that represents a column of secure
+/// field elements.
+pub struct SecureColumn<B: Backend> {
+    pub columns: [Col<B, BaseField>; SECURE_EXTENSION_DEGREE],
+}
+impl SecureColumn<CPUBackend> {
+    pub fn at(&self, index: usize) -> SecureField {
+        SecureField::from_m31_array(std::array::from_fn(|i| self.columns[i][index]))
+    }
+
+    pub fn set(&mut self, index: usize, value: SecureField) {
+        self.columns
+            .iter_mut()
+            .map(|c| &mut c[index])
+            .assign(value.to_m31_array());
+    }
+}
+impl<B: Backend> SecureColumn<B> {
+    pub fn zeros(len: usize) -> Self {
+        Self {
+            columns: std::array::from_fn(|_| Col::<B, BaseField>::zeros(len)),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.columns[0].len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.columns[0].is_empty()
+    }
+}

src/core/poly/circle/mod.rs

@@ -10,7 +10,7 @@ pub use domain::{CircleDomain, MAX_CIRCLE_DOMAIN_LOG_SIZE};
 pub use evaluation::{CircleEvaluation, CosetSubEvaluation};
 pub use ops::PolyOps;
 pub use poly::CirclePoly;
-pub use secure_poly::{combine_secure_value, SecureCirclePoly};
+pub use secure_poly::SecureCirclePoly;
 
 #[cfg(test)]
 mod tests {

src/core/poly/circle/secure_poly.rs

@@ -1,15 +1,15 @@
 use std::ops::Deref;
 
-use crate::core::air::evaluation::SECURE_EXTENSION_DEGREE;
 use crate::core::backend::cpu::CPUCirclePoly;
 use crate::core::circle::CirclePoint;
 use crate::core::fields::qm31::SecureField;
+use crate::core::fields::secure_column::SECURE_EXTENSION_DEGREE;
 
 pub struct SecureCirclePoly(pub [CPUCirclePoly; SECURE_EXTENSION_DEGREE]);
 
 impl SecureCirclePoly {
     pub fn eval_at_point(&self, point: CirclePoint<SecureField>) -> SecureField {
-        combine_secure_value(self.eval_columns_at_point(point))
+        Self::eval_from_partial_evals(self.eval_columns_at_point(point))
     }
 
     pub fn eval_columns_at_point(
@@ -23,6 +23,16 @@ impl SecureCirclePoly {
             self[3].eval_at_point(point),
         ]
     }
+
+    /// Evaluates the polynomial at a point, given evaluations of its composing base field
+    /// polynomials at that point.
+    pub fn eval_from_partial_evals(evals: [SecureField; SECURE_EXTENSION_DEGREE]) -> SecureField {
+        let mut res = evals[0];
+        res += evals[1] * SecureField::from_u32_unchecked(0, 1, 0, 0);
+        res += evals[2] * SecureField::from_u32_unchecked(0, 0, 1, 0);
+        res += evals[3] * SecureField::from_u32_unchecked(0, 0, 0, 1);
+        res
+    }
 }
 
 impl Deref for SecureCirclePoly {
@@ -32,11 +42,3 @@ impl Deref for SecureCirclePoly {
         &self.0
     }
 }
-
-pub fn combine_secure_value(value: [SecureField; SECURE_EXTENSION_DEGREE]) -> SecureField {
-    let mut res = value[0];
-    res += value[1] * SecureField::from_u32_unchecked(0, 1, 0, 0);
-    res += value[2] * SecureField::from_u32_unchecked(0, 0, 1, 0);
-    res += value[3] * SecureField::from_u32_unchecked(0, 0, 0, 1);
-    res
-}

src/core/prover/mod.rs

@@ -3,7 +3,7 @@ use thiserror::Error;
 
 use super::commitment_scheme::{CommitmentSchemeProof, TreeVec};
 use super::fri::FriVerificationError;
-use super::poly::circle::MAX_CIRCLE_DOMAIN_LOG_SIZE;
+use super::poly::circle::{SecureCirclePoly, MAX_CIRCLE_DOMAIN_LOG_SIZE};
 use super::proof_of_work::ProofOfWorkVerificationError;
 use super::ColumnVec;
 use crate::commitment_scheme::blake2_hash::Blake2sHasher;
@@ -16,7 +16,7 @@ use crate::core::circle::CirclePoint;
 use crate::core::commitment_scheme::{CommitmentSchemeProver, CommitmentSchemeVerifier};
 use crate::core::fields::m31::BaseField;
 use crate::core::fields::qm31::SecureField;
-use crate::core::poly::circle::{combine_secure_value, CircleEvaluation};
+use crate::core::poly::circle::CircleEvaluation;
 use crate::core::poly::BitReversedOrder;
 use crate::core::ComponentVec;
 
@@ -158,7 +158,7 @@ fn opened_values_to_mask(
     air: &impl Air<CPUBackend>,
     mut opened_values: TreeVec<ColumnVec<Vec<SecureField>>>,
 ) -> Result<(ComponentVec<Vec<SecureField>>, SecureField), ()> {
-    let composition_oods_values = combine_secure_value(
+    let composition_oods_values = SecureCirclePoly::eval_from_partial_evals(
         opened_values
             .pop()
             .unwrap()