Minor tweaks

src/field/extension_field/algebra.rs

@@ -3,7 +3,7 @@ use std::fmt::{Debug, Display, Formatter};
 use std::iter::{Product, Sum};
 use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
-/// Let `F_D` be the extension `F[X]/(X^D-W)`. Then `ExtensionAlgebra<F_D>` is the quotient `F_D[X]/(X^D-W)`.
+/// Let `F_D` be the optimal extension field `F[X]/(X^D-W)`. Then `ExtensionAlgebra<F_D>` is the quotient `F_D[X]/(X^D-W)`.
 /// It's a `D`-dimensional algebra over `F_D` useful to lift the multiplication over `F_D` to a multiplication over `(F_D)^D`.
 #[derive(Copy, Clone)]
 pub struct ExtensionAlgebra<F: OEF<D>, const D: usize>([F; D]);

src/field/extension_field/target.rs

@@ -1,4 +1,5 @@
 use crate::circuit_builder::CircuitBuilder;
+use crate::field::extension_field::algebra::ExtensionAlgebra;
 use crate::field::extension_field::{Extendable, FieldExtension, OEF};
 use crate::field::field::Field;
 use crate::target::Target;
@@ -35,11 +36,8 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
 
     pub fn constant_ext_algebra(
         &mut self,
-        c: <<F as Extendable<D>>::Extension as Extendable<D>>::Extension,
+        c: ExtensionAlgebra<F::Extension, D>,
-    ) -> ExtensionAlgebraTarget<D>
+    ) -> ExtensionAlgebraTarget<D> {
-    where
-        F::Extension: Extendable<D>,
-    {
         let c_parts = c.to_basefield_array();
         let mut parts = [self.zero_extension(); D];
         for i in 0..D {
@@ -60,13 +58,8 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         self.constant_extension(F::Extension::TWO)
     }
 
-    pub fn zero_ext_algebra(&mut self) -> ExtensionAlgebraTarget<D>
+    pub fn zero_ext_algebra(&mut self) -> ExtensionAlgebraTarget<D> {
-    where
+        self.constant_ext_algebra(ExtensionAlgebra::ZERO)
-        F::Extension: Extendable<D>,
-    {
-        self.constant_ext_algebra(
-            <<F as Extendable<D>>::Extension as Extendable<D>>::Extension::ZERO,
-        )
     }
 
     pub fn add_extension(
@@ -142,7 +135,7 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
 
     pub fn mul_ext_algebra(
         &mut self,
-        mut a: ExtensionAlgebraTarget<D>,
+        a: ExtensionAlgebraTarget<D>,
         b: ExtensionAlgebraTarget<D>,
     ) -> ExtensionAlgebraTarget<D> {
         let mut res = [self.zero_extension(); D];
@@ -195,10 +188,7 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         &mut self,
         a: ExtensionTarget<D>,
         mut b: ExtensionAlgebraTarget<D>,
-    ) -> ExtensionAlgebraTarget<D>
+    ) -> ExtensionAlgebraTarget<D> {
-    where
-        F::Extension: Extendable<D>,
-    {
         for i in 0..D {
             b.0[i] = self.mul_extension(a, b.0[i]);
         }

src/gadgets/polynomial.rs

@@ -33,9 +33,9 @@ impl<const D: usize> PolynomialCoeffsExtTarget<D> {
     }
 }
 
-pub struct PolynomialCoeffsExtExtTarget<const D: usize>(pub Vec<ExtensionAlgebraTarget<D>>);
+pub struct PolynomialCoeffsExtAlgebraTarget<const D: usize>(pub Vec<ExtensionAlgebraTarget<D>>);
 
-impl<const D: usize> PolynomialCoeffsExtExtTarget<D> {
+impl<const D: usize> PolynomialCoeffsExtAlgebraTarget<D> {
     pub fn eval_scalar<F>(
         &self,
         builder: &mut CircuitBuilder<F, D>,

src/gates/interpolation.rs

@@ -7,7 +7,7 @@ use crate::field::extension_field::algebra::PolynomialCoeffsAlgebra;
 use crate::field::extension_field::target::ExtensionTarget;
 use crate::field::extension_field::{Extendable, FieldExtension};
 use crate::field::lagrange::interpolant;
-use crate::gadgets::polynomial::PolynomialCoeffsExtExtTarget;
+use crate::gadgets::polynomial::PolynomialCoeffsExtAlgebraTarget;
 use crate::gates::gate::{Gate, GateRef};
 use crate::generator::{SimpleGenerator, WitnessGenerator};
 use crate::target::Target;
@@ -140,7 +140,7 @@ where
         let coeffs = (0..self.num_points)
             .map(|i| vars.get_local_ext_algebra(self.wires_coeff(i)))
             .collect();
-        let interpolant = PolynomialCoeffsExtExtTarget(coeffs);
+        let interpolant = PolynomialCoeffsExtAlgebraTarget(coeffs);
 
         for i in 0..self.num_points {
             let point = vars.local_wires[self.wire_point(i)];
@@ -280,15 +280,21 @@ where
 mod tests {
     use std::marker::PhantomData;
 
+    use crate::circuit_builder::CircuitBuilder;
+    use crate::circuit_data::CircuitConfig;
     use crate::field::crandall_field::CrandallField;
     use crate::field::extension_field::quartic::QuarticCrandallField;
     use crate::field::extension_field::FieldExtension;
     use crate::field::field::Field;
+    use crate::fri::FriConfig;
     use crate::gates::gate::Gate;
     use crate::gates::gate_testing::test_low_degree;
     use crate::gates::interpolation::InterpolationGate;
     use crate::polynomial::polynomial::PolynomialCoeffs;
+    use crate::prover::PLONK_BLINDING;
     use crate::vars::EvaluationVars;
+    use crate::verifier::verify;
+    use crate::witness::PartialWitness;
 
     #[test]
     fn wire_indices() {