Addition and multiplication for ExtensionTarget

src/field/extension_field/mod.rs

@@ -2,6 +2,7 @@ use crate::field::field::Field;
 
 pub mod quadratic;
 pub mod quartic;
+pub mod target;
 
 /// Optimal extension field trait.
 /// A degree `d` field extension is optimal if there exists a base field element `W`,
@@ -27,11 +28,7 @@ pub trait OEF<const D: usize>: FieldExtension<D> {
 }
 
 pub trait Extendable<const D: usize>: Sized {
-    type Extension: Field + FieldExtension<D, BaseField = Self> + From<Self>;
-}
-
-impl<F: Field> Extendable<1> for F {
-    type Extension = Self;
+    type Extension: Field + FieldExtension<D, BaseField = Self> + OEF<D> + From<Self>;
 }
 
 pub trait FieldExtension<const D: usize>: Field {

src/field/extension_field/target.rs

@@ -1,14 +1,46 @@
 use crate::circuit_builder::CircuitBuilder;
-use crate::field::extension_field::{Extendable, FieldExtension};
+use crate::field::extension_field::{Extendable, FieldExtension, OEF};
 use crate::field::field::Field;
 use crate::target::Target;
 
+#[derive(Copy, Clone, Debug)]
 pub struct ExtensionTarget<const D: usize>([Target; D]);
 
 impl<F: Field> CircuitBuilder<F> {
-    pub fn mul_extension<const D: usize>(a: ExtensionTarget<D>, b: ExtensionTarget<D>) -> ()
+    pub fn add_extension<const D: usize>(
+        &mut self,
+        mut a: ExtensionTarget<D>,
+        b: ExtensionTarget<D>,
+    ) -> ExtensionTarget<D>
     where
         F: Extendable<D>,
     {
+        for i in 0..D {
+            a.0[i] = self.add(a.0[i], b.0[i]);
+        }
+        a
+    }
+
+    pub fn mul_extension<const D: usize>(
+        &mut self,
+        a: ExtensionTarget<D>,
+        b: ExtensionTarget<D>,
+    ) -> ExtensionTarget<D>
+    where
+        F: Extendable<D>,
+    {
+        let w = self.constant(F::Extension::W);
+        let mut res = [self.zero(); D];
+        for i in 0..D {
+            for j in 0..D {
+                res[(i + j) % D] = if i + j < D {
+                    self.mul_add(a.0[i], b.0[j], res[(i + j) % D])
+                } else {
+                    let tmp = self.mul_add(a.0[i], b.0[j], res[(i + j) % D]);
+                    self.mul(w, tmp)
+                }
+            }
+        }
+        ExtensionTarget(res)
     }
 }