From 417e6055ae0a6f8ac0913175ca4d847fe0314db9 Mon Sep 17 00:00:00 2001
From: wborgeaud <williamborgeaud@gmail.com>
Date: Mon, 9 Aug 2021 13:21:42 +0200
Subject: [PATCH] Optimize coset in `compute_evaluation`

---
 src/fri/recursive_verifier.rs | 21 +++++++++++++++------
 src/gadgets/arithmetic.rs     | 10 ++++++++++
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/fri/recursive_verifier.rs b/src/fri/recursive_verifier.rs
index 5eb95a34..a0937554 100644
--- a/src/fri/recursive_verifier.rs
+++ b/src/fri/recursive_verifier.rs
@@ -40,14 +40,23 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         let coset_start = self.mul(start, x);
 
         // The answer is gotten by interpolating {(x*g^i, P(x*g^i))} and evaluating at beta.
-        let points = g
+        let g_powers = g
             .powers()
-            .map(|y| {
-                let yt = self.constant(y);
-                self.mul(coset_start, yt)
-            })
-            .zip(evals)
+            .take(arity)
+            .map(|y| self.constant(y))
             .collect::<Vec<_>>();
+        let mut coset = Vec::new();
+        for i in 0..arity / 2 {
+            let res = self.mul_two(
+                coset_start,
+                g_powers[2 * i],
+                coset_start,
+                g_powers[2 * i + 1],
+            );
+            coset.push(res.0);
+            coset.push(res.1);
+        }
+        let points = coset.into_iter().zip(evals).collect::<Vec<_>>();
 
         self.interpolate(&points, beta)
     }
diff --git a/src/gadgets/arithmetic.rs b/src/gadgets/arithmetic.rs
index d670f58d..9779da7e 100644
--- a/src/gadgets/arithmetic.rs
+++ b/src/gadgets/arithmetic.rs
@@ -86,6 +86,16 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         self.arithmetic(F::ONE, x, y, F::ZERO, x)
     }
 
+    /// Computes `x * y`.
+    pub fn mul_two(&mut self, a0: Target, b0: Target, a1: Target, b1: Target) -> (Target, Target) {
+        let a0_ext = self.convert_to_ext(a0);
+        let b0_ext = self.convert_to_ext(b0);
+        let a1_ext = self.convert_to_ext(a1);
+        let b1_ext = self.convert_to_ext(b1);
+        let res = self.mul_two_extension(a0_ext, b0_ext, a1_ext, b1_ext);
+        (res.0 .0[0], res.1 .0[0])
+    }
+
     /// Multiply `n` `Target`s with `ceil(n/2) + 1` `ArithmeticExtensionGate`s.
     pub fn mul_many(&mut self, terms: &[Target]) -> Target {
         let terms_ext = terms