remove not used FieldOps trait

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

@@ -7,11 +7,10 @@
 use itertools::Itertools;
 use tracing::{span, Level};
 
-use crate::core::backend::{Backend, Col, Column, CpuBackend};
+use crate::core::backend::{Backend, Col, Column, ColumnOps, CpuBackend};
 use crate::core::fields::m31::BaseField;
 use crate::core::fields::qm31::SecureField;
 use crate::core::fields::secure_column::SecureColumnByCoords;
-use crate::core::fields::FieldOps;
 use crate::core::poly::circle::{CanonicCoset, CircleEvaluation, CirclePoly, SecureCirclePoly};
 use crate::core::poly::BitReversedOrder;
 
@@ -149,7 +148,7 @@ impl<B: Backend> DomainEvaluationAccumulator<B> {
     }
 }
 
-pub trait AccumulationOps: FieldOps<BaseField> + Sized {
+pub trait AccumulationOps: ColumnOps<BaseField> + Sized {
     /// Accumulates other into column:
     ///   column = column + other.
     fn accumulate(column: &mut SecureColumnByCoords<Self>, other: &SecureColumnByCoords<Self>);

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

@@ -12,8 +12,7 @@ use std::fmt::Debug;
 
 use serde::{Deserialize, Serialize};
 
-use super::{Backend, BackendForChannel, Column, ColumnOps, FieldOps};
-use crate::core::fields::Field;
+use super::{Backend, BackendForChannel, Column, ColumnOps};
 use crate::core::lookups::mle::Mle;
 use crate::core::poly::circle::{CircleEvaluation, CirclePoly};
 use crate::core::utils::bit_reverse_index;
@@ -54,14 +53,6 @@ impl<T: Debug + Clone + Default> ColumnOps<T> for CpuBackend {
     }
 }
 
-impl<F: Field> FieldOps<F> for CpuBackend {
-    /// Batch inversion using the Montgomery's trick.
-    // TODO(Ohad): Benchmark this function.
-    fn batch_inverse(column: &Self::Column, dst: &mut Self::Column) {
-        F::batch_inverse(column, &mut dst[..]);
-    }
-}
-
 impl<T: Debug + Clone + Default> Column<T> for Vec<T> {
     fn zeros(len: usize) -> Self {
         vec![T::default(); len]
@@ -97,7 +88,7 @@ mod tests {
     use rand::rngs::SmallRng;
 
     use crate::core::backend::cpu::bit_reverse;
-    use crate::core::backend::{Column, CpuBackend, FieldOps};
+    use crate::core::backend::Column;
     use crate::core::fields::qm31::QM31;
     use crate::core::fields::FieldExpOps;
 
@@ -120,9 +111,9 @@ mod tests {
         let mut rng = SmallRng::seed_from_u64(0);
         let column = rng.gen::<[QM31; 16]>().to_vec();
         let expected = column.iter().map(|e| e.inverse()).collect_vec();
-        let mut dst = Column::zeros(column.len());
+        let mut dst = Vec::zeros(column.len());
 
-        CpuBackend::batch_inverse(&column, &mut dst);
+        FieldExpOps::batch_inverse(&column, &mut dst);
 
         assert_eq!(expected, dst);
     }

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

@@ -6,7 +6,6 @@ use super::air::accumulation::AccumulationOps;
 use super::channel::MerkleChannel;
 use super::fields::m31::BaseField;
 use super::fields::qm31::SecureField;
-use super::fields::FieldOps;
 use super::fri::FriOps;
 use super::lookups::gkr_prover::GkrOps;
 use super::pcs::quotients::QuotientOps;
@@ -21,8 +20,8 @@ pub trait Backend:
     Copy
     + Clone
     + Debug
-    + FieldOps<BaseField>
-    + FieldOps<SecureField>
+    + ColumnOps<BaseField>
+    + ColumnOps<SecureField>
     + PolyOps
     + QuotientOps
     + FriOps

crates/prover/src/core/backend/simd/column.rs

@@ -18,19 +18,6 @@ use crate::core::fields::cm31::CM31;
 use crate::core::fields::m31::BaseField;
 use crate::core::fields::qm31::SecureField;
 use crate::core::fields::secure_column::{SecureColumnByCoords, SECURE_EXTENSION_DEGREE};
-use crate::core::fields::{FieldExpOps, FieldOps};
-
-impl FieldOps<BaseField> for SimdBackend {
-    fn batch_inverse(column: &BaseColumn, dst: &mut BaseColumn) {
-        PackedBaseField::batch_inverse(&column.data, &mut dst.data);
-    }
-}
-
-impl FieldOps<SecureField> for SimdBackend {
-    fn batch_inverse(column: &SecureColumn, dst: &mut SecureColumn) {
-        PackedSecureField::batch_inverse(&column.data, &mut dst.data);
-    }
-}
 
 /// An efficient structure for storing and operating on a arbitrary number of [`BaseField`] values.
 #[derive(Clone, Debug)]

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

@@ -4,18 +4,11 @@ use std::ops::{Mul, MulAssign, Neg};
 
 use num_traits::{NumAssign, NumAssignOps, NumOps, One};
 
-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.
-    fn batch_inverse(column: &Self::Column, dst: &mut Self::Column);
-}
-
 pub trait FieldExpOps: Mul<Output = Self> + MulAssign + Sized + One + Clone {
     fn square(&self) -> Self {
         self.clone() * self.clone()

crates/prover/src/core/fields/secure_column.rs

@@ -3,16 +3,16 @@ use std::iter::zip;
 
 use super::m31::BaseField;
 use super::qm31::SecureField;
-use super::{ExtensionOf, FieldOps};
-use crate::core::backend::{Col, Column, CpuBackend};
+use super::ExtensionOf;
+use crate::core::backend::{Col, Column, ColumnOps, CpuBackend};
 
 pub const SECURE_EXTENSION_DEGREE: usize =
     <SecureField as ExtensionOf<BaseField>>::EXTENSION_DEGREE;
 
 /// A column major array of `SECURE_EXTENSION_DEGREE` base field columns, that represents a column
 /// of secure field element coordinates.
 #[derive(Clone, Debug)]
-pub struct SecureColumnByCoords<B: FieldOps<BaseField>> {
+pub struct SecureColumnByCoords<B: ColumnOps<BaseField>> {
     pub columns: [Col<B, BaseField>; SECURE_EXTENSION_DEGREE],
 }
 impl SecureColumnByCoords<CpuBackend> {
@@ -21,7 +21,7 @@ impl SecureColumnByCoords<CpuBackend> {
         (0..self.len()).map(|i| self.at(i)).collect()
     }
 }
-impl<B: FieldOps<BaseField>> SecureColumnByCoords<B> {
+impl<B: ColumnOps<BaseField>> SecureColumnByCoords<B> {
     pub fn at(&self, index: usize) -> SecureField {
         SecureField::from_m31_array(std::array::from_fn(|i| self.columns[i].at(index)))
     }

crates/prover/src/core/fri.rs

@@ -10,12 +10,11 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tracing::instrument;
 
-use super::backend::{Col, CpuBackend};
+use super::backend::{Col, ColumnOps, CpuBackend};
 use super::channel::{Channel, MerkleChannel};
 use super::fields::m31::BaseField;
 use super::fields::qm31::{SecureField, QM31};
 use super::fields::secure_column::{SecureColumnByCoords, SECURE_EXTENSION_DEGREE};
-use super::fields::FieldOps;
 use super::poly::circle::{CircleDomain, PolyOps, SecureEvaluation};
 use super::poly::line::{LineEvaluation, LinePoly};
 use super::poly::twiddles::TwiddleTree;
@@ -75,7 +74,7 @@ impl FriConfig {
     }
 }
 
-pub trait FriOps: FieldOps<BaseField> + PolyOps + Sized + FieldOps<SecureField> {
+pub trait FriOps: ColumnOps<BaseField> + PolyOps + Sized + ColumnOps<SecureField> {
     /// Folds a degree `d` polynomial into a degree `d/2` polynomial.
     ///
     /// Let `eval` be a polynomial evaluated on a [LineDomain] `E`, `alpha` be a random field

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

@@ -6,10 +6,10 @@ use educe::Educe;
 use super::{CanonicCoset, CircleDomain, CirclePoly, PolyOps};
 use crate::core::backend::cpu::CpuCircleEvaluation;
 use crate::core::backend::simd::SimdBackend;
-use crate::core::backend::{Col, Column, CpuBackend};
+use crate::core::backend::{Col, Column, ColumnOps, CpuBackend};
 use crate::core::circle::{CirclePointIndex, Coset};
 use crate::core::fields::m31::BaseField;
-use crate::core::fields::{ExtensionOf, FieldOps};
+use crate::core::fields::ExtensionOf;
 use crate::core::poly::twiddles::TwiddleTree;
 use crate::core::poly::{BitReversedOrder, NaturalOrder};
 use crate::core::utils::bit_reverse_index;
@@ -18,13 +18,13 @@ use crate::core::utils::bit_reverse_index;
 /// The values are ordered according to the [CircleDomain] ordering.
 #[derive(Educe)]
 #[educe(Clone, Debug)]
-pub struct CircleEvaluation<B: FieldOps<F>, F: ExtensionOf<BaseField>, EvalOrder = NaturalOrder> {
+pub struct CircleEvaluation<B: ColumnOps<F>, F: ExtensionOf<BaseField>, EvalOrder = NaturalOrder> {
     pub domain: CircleDomain,
     pub values: Col<B, F>,
     _eval_order: PhantomData<EvalOrder>,
 }
 
-impl<B: FieldOps<F>, F: ExtensionOf<BaseField>, EvalOrder> CircleEvaluation<B, F, EvalOrder> {
+impl<B: ColumnOps<F>, F: ExtensionOf<BaseField>, EvalOrder> CircleEvaluation<B, F, EvalOrder> {
     pub fn new(domain: CircleDomain, values: Col<B, F>) -> Self {
         assert_eq!(domain.size(), values.len());
         Self {
@@ -38,7 +38,7 @@ impl<B: FieldOps<F>, F: ExtensionOf<BaseField>, EvalOrder> CircleEvaluation<B, F
 // Note: The concrete implementation of the poly operations is in the specific backend used.
 // For example, the CPU backend implementation is in `src/core/backend/cpu/poly.rs`.
 // TODO(first) Remove NaturalOrder.
-impl<F: ExtensionOf<BaseField>, B: FieldOps<F>> CircleEvaluation<B, F, NaturalOrder> {
+impl<F: ExtensionOf<BaseField>, B: ColumnOps<F>> CircleEvaluation<B, F, NaturalOrder> {
     // TODO(alont): Remove. Is this even used.
     pub fn get_at(&self, point_index: CirclePointIndex) -> F {
         self.values
@@ -95,7 +95,7 @@ impl<B: PolyOps> CircleEvaluation<B, BaseField, BitReversedOrder> {
     }
 }
 
-impl<B: FieldOps<F>, F: ExtensionOf<BaseField>> CircleEvaluation<B, F, BitReversedOrder> {
+impl<B: ColumnOps<F>, F: ExtensionOf<BaseField>> CircleEvaluation<B, F, BitReversedOrder> {
     pub fn bit_reverse(mut self) -> CircleEvaluation<B, F, NaturalOrder> {
         B::bit_reverse_column(&mut self.values);
         CircleEvaluation::new(self.domain, self.values)
@@ -111,14 +111,14 @@ impl<B: FieldOps<F>, F: ExtensionOf<BaseField>> CircleEvaluation<B, F, BitRevers
 
 impl<F: ExtensionOf<BaseField>, EvalOrder> CircleEvaluation<SimdBackend, F, EvalOrder>
 where
-    SimdBackend: FieldOps<F>,
+    SimdBackend: ColumnOps<F>,
 {
     pub fn to_cpu(&self) -> CircleEvaluation<CpuBackend, F, EvalOrder> {
         CircleEvaluation::new(self.domain, self.values.to_cpu())
     }
 }
 
-impl<B: FieldOps<F>, F: ExtensionOf<BaseField>, EvalOrder> Deref
+impl<B: ColumnOps<F>, F: ExtensionOf<BaseField>, EvalOrder> Deref
     for CircleEvaluation<B, F, EvalOrder>
 {
     type Target = Col<B, F>;

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

@@ -1,17 +1,16 @@
 use itertools::Itertools;
 
 use super::{CanonicCoset, CircleDomain, CircleEvaluation, CirclePoly};
-use crate::core::backend::Col;
+use crate::core::backend::{Col, ColumnOps};
 use crate::core::circle::{CirclePoint, Coset};
 use crate::core::fields::m31::BaseField;
 use crate::core::fields::qm31::SecureField;
-use crate::core::fields::FieldOps;
 use crate::core::poly::twiddles::TwiddleTree;
 use crate::core::poly::BitReversedOrder;
 use crate::core::ColumnVec;
 
 /// Operations on BaseField polynomials.
-pub trait PolyOps: FieldOps<BaseField> + Sized {
+pub trait PolyOps: ColumnOps<BaseField> + Sized {
     // TODO(alont): Use a column instead of this type.
     /// The type for precomputed twiddles.
     type Twiddles;

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

@@ -1,15 +1,14 @@
 use super::{CircleDomain, CircleEvaluation, PolyOps};
-use crate::core::backend::{Col, Column};
+use crate::core::backend::{Col, Column, ColumnOps};
 use crate::core::circle::CirclePoint;
 use crate::core::fields::m31::BaseField;
 use crate::core::fields::qm31::SecureField;
-use crate::core::fields::FieldOps;
 use crate::core::poly::twiddles::TwiddleTree;
 use crate::core::poly::BitReversedOrder;
 
 /// A polynomial defined on a [CircleDomain].
 #[derive(Clone, Debug)]
-pub struct CirclePoly<B: FieldOps<BaseField>> {
+pub struct CirclePoly<B: ColumnOps<BaseField>> {
     /// Coefficients of the polynomial in the FFT basis.
     /// Note: These are not the coefficients of the polynomial in the standard
     /// monomial basis. The FFT basis is a tensor product of the twiddles:

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

@@ -2,16 +2,15 @@ use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 
 use super::{CircleDomain, CircleEvaluation, CirclePoly, PolyOps};
-use crate::core::backend::CpuBackend;
+use crate::core::backend::{ColumnOps, CpuBackend};
 use crate::core::circle::CirclePoint;
 use crate::core::fields::m31::BaseField;
 use crate::core::fields::qm31::SecureField;
 use crate::core::fields::secure_column::{SecureColumnByCoords, SECURE_EXTENSION_DEGREE};
-use crate::core::fields::FieldOps;
 use crate::core::poly::twiddles::TwiddleTree;
 use crate::core::poly::BitReversedOrder;
 
-pub struct SecureCirclePoly<B: FieldOps<BaseField>>(pub [CirclePoly<B>; SECURE_EXTENSION_DEGREE]);
+pub struct SecureCirclePoly<B: ColumnOps<BaseField>>(pub [CirclePoly<B>; SECURE_EXTENSION_DEGREE]);
 
 impl<B: PolyOps> SecureCirclePoly<B> {
     pub fn eval_at_point(&self, point: CirclePoint<SecureField>) -> SecureField {
@@ -49,7 +48,7 @@ impl<B: PolyOps> SecureCirclePoly<B> {
     }
 }
 
-impl<B: FieldOps<BaseField>> Deref for SecureCirclePoly<B> {
+impl<B: ColumnOps<BaseField>> Deref for SecureCirclePoly<B> {
     type Target = [CirclePoly<B>; SECURE_EXTENSION_DEGREE];
 
     fn deref(&self) -> &Self::Target {
@@ -62,13 +61,13 @@ impl<B: FieldOps<BaseField>> Deref for SecureCirclePoly<B> {
 /// The evaluation is stored as a column major array of [`SECURE_EXTENSION_DEGREE`] many base field
 /// evaluations. The evaluations are ordered according to the [CircleDomain] ordering.
 #[derive(Clone)]
-pub struct SecureEvaluation<B: FieldOps<BaseField>, EvalOrder> {
+pub struct SecureEvaluation<B: ColumnOps<BaseField>, EvalOrder> {
     pub domain: CircleDomain,
     pub values: SecureColumnByCoords<B>,
     _eval_order: PhantomData<EvalOrder>,
 }
 
-impl<B: FieldOps<BaseField>, EvalOrder> SecureEvaluation<B, EvalOrder> {
+impl<B: ColumnOps<BaseField>, EvalOrder> SecureEvaluation<B, EvalOrder> {
     pub fn new(domain: CircleDomain, values: SecureColumnByCoords<B>) -> Self {
         assert_eq!(domain.size(), values.len());
         Self {
@@ -94,15 +93,15 @@ impl<B: FieldOps<BaseField>, EvalOrder> SecureEvaluation<B, EvalOrder> {
     }
 }
 
-impl<B: FieldOps<BaseField>, EvalOrder> Deref for SecureEvaluation<B, EvalOrder> {
+impl<B: ColumnOps<BaseField>, EvalOrder> Deref for SecureEvaluation<B, EvalOrder> {
     type Target = SecureColumnByCoords<B>;
 
     fn deref(&self) -> &Self::Target {
         &self.values
     }
 }
 
-impl<B: FieldOps<BaseField>, EvalOrder> DerefMut for SecureEvaluation<B, EvalOrder> {
+impl<B: ColumnOps<BaseField>, EvalOrder> DerefMut for SecureEvaluation<B, EvalOrder> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.values
     }

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

@@ -16,7 +16,7 @@ use crate::core::fft::ibutterfly;
 use crate::core::fields::m31::BaseField;
 use crate::core::fields::qm31::SecureField;
 use crate::core::fields::secure_column::SecureColumnByCoords;
-use crate::core::fields::{ExtensionOf, FieldOps};
+use crate::core::fields::ExtensionOf;
 
 /// Domain comprising of the x-coordinates of points in a [Coset].
 ///
@@ -186,13 +186,13 @@ impl DerefMut for LinePoly {
 // only used by FRI where evaluations are in bit-reversed order.
 // TODO(andrew): Remove pub.
 #[derive(Clone, Debug)]
-pub struct LineEvaluation<B: FieldOps<BaseField>> {
+pub struct LineEvaluation<B: ColumnOps<BaseField>> {
     /// Evaluations of a univariate polynomial on `domain`.
     pub values: SecureColumnByCoords<B>,
     domain: LineDomain,
 }
 
-impl<B: FieldOps<BaseField>> LineEvaluation<B> {
+impl<B: ColumnOps<BaseField>> LineEvaluation<B> {
     /// Creates new [LineEvaluation] from a set of polynomial evaluations over a [LineDomain].
     ///
     /// # Panics