Merge pull request #181 from o1-labs/expr-ec-ops

Complete EC addition gate

Author: imeckler

circuits/plonk-15-wires/src/expr.rs

@@ -124,6 +124,7 @@ pub enum Column {
 impl Column {
     fn domain(&self) -> Domain {
         match self {
+            Column::Index(GateType::CompleteAdd) => Domain::D4,
             _ => Domain::D8,
         }
     }
@@ -641,7 +642,7 @@ impl<'a, F: FftField> EvalResult<'a, F> {
 
                 let n = res_domain.1.size as usize;
                 let v: Vec<_> = (0..n).into_par_iter().map(|i| {
-                    es1.evals[(scale1 * i + (d1 as usize) * s1) % es1.evals.len()] 
+                    es1.evals[(scale1 * i + (d1 as usize) * s1) % es1.evals.len()]
                         + es2.evals[(scale2 * i + (d2 as usize) * s2) % es2.evals.len()]
                 }).collect();
 
@@ -790,23 +791,16 @@ impl<'a, F: FftField> EvalResult<'a, F> {
 
                 EvalResult::init(
                     res_domain,
-                    |i| es1.evals[(scale1 * i + (d1 as usize) * s1) % es1.evals.len()] * es2.evals[(scale2 * i + (d2 as usize) * s2) % es1.evals.len()])
+                    |i| {
+                        es1.evals[(scale1 * i + (d1 as usize) * s1) % es1.evals.len()]
+                            * es2.evals[(scale2 * i + (d2 as usize) * s2) % es2.evals.len()]
+                    })
             }
         }
     }
 
 }
 
-/*
-fn eval_result_op<'a, 'b, 'c, F: FftField>(op: Op2, dom: (Domain, D<F>), x: EvalResult<'a, F>, y: EvalResult<'b, F>) -> EvalResult<'c, F> {
-    match op {
-        Op2::Mul => x.mul(y, dom),
-        Op2::Add => x.add(y, dom),
-        Op2::Sub => x.sub(y, dom),
-    }
-}
-*/
-
 fn get_domain<F: FftField>(d: Domain, env: &Environment<F>) -> D<F> {
     match d {
         Domain::D1 => env.domain.d1,
@@ -816,6 +810,18 @@ fn get_domain<F: FftField>(d: Domain, env: &Environment<F>) -> D<F> {
     }
 }
 
+impl<F: Field> Expr<ConstantExpr<F>> {
+    /// Combines multiple constraints `[c0, ..., cn]` into a single constraint
+    /// `alpha^alpha0 * c0 + alpha^{alpha0 + 1} * c1 + ... + alpha^{alpha0 + n} * cn`.
+    pub fn combine_constraints(alpha0: usize, cs: Vec<Self>) -> Self {
+        let zero = Expr::<ConstantExpr<F>>::zero();
+        cs.into_iter().zip(alpha0..).map(|(c, i)| {
+            Expr::Constant(ConstantExpr::Alpha.pow(i)) * c
+        }).fold(zero, |acc, x| acc + x)
+    }
+
+}
+
 impl<F: FftField> Expr<ConstantExpr<F>> {
     /// Convenience function for constructing expressions from literal
     /// field elements.
@@ -875,15 +881,6 @@ impl<F: FftField> Expr<ConstantExpr<F>> {
         }
     }
 
-    /// Combines multiple constraints `[c0, ..., cn]` into a single constraint
-    /// `alpha^alpha0 * c0 + alpha^{alpha0 + 1} * c1 + ... + alpha^{alpha0 + n} * cn`.
-    pub fn combine_constraints(alpha0: usize, cs: Vec<Self>) -> Self {
-        let zero = Expr::<ConstantExpr<F>>::zero();
-        cs.into_iter().zip(alpha0..).map(|(c, i)| {
-            Expr::Constant(ConstantExpr::Alpha.pow(i)) * c
-        }).fold(zero, |acc, x| acc + x)
-    }
-
     /// The expression `beta`.
     pub fn beta() -> Self {
         Expr::Constant(ConstantExpr::Beta)

circuits/plonk-15-wires/src/gate.rs

@@ -111,10 +111,8 @@ pub enum GateType {
     Generic,
     /// Poseidon permutation gate
     Poseidon,
-    /// EC addition in Affine form
-    Add,
-    /// EC point doubling in Affine form
-    Double,
+    /// Complete EC addition in Affine form
+    CompleteAdd,
     /// EC variable base scalar multiplication
     Vbmul,
     /// EC variable base scalar multiplication with group endomorphim optimization
@@ -406,8 +404,7 @@ impl<F: FftField> CircuitGate<F> {
             Zero => Ok(()),
             Generic => self.verify_generic(witness),
             Poseidon => self.verify_poseidon(witness, cs),
-            Add => self.verify_add(witness),
-            Double => self.verify_double(witness),
+            CompleteAdd => self.verify_complete_add(witness),
             Vbmul => self.verify_vbmul(witness),
             Endomul => self.verify_endomul(witness, cs),
             ChaCha0 | ChaCha1 | ChaCha2 | ChaChaFinal => panic!("todo")

circuits/plonk-15-wires/src/gates/addition.rs

@@ -1,5 +1,3 @@
-pub mod addition;
-pub mod double;
 pub mod endosclmul;
 pub mod generic;
 pub mod poseidon;

circuits/plonk-15-wires/src/gates/double.rs

@@ -69,10 +69,7 @@ pub struct ConstraintSystem<F: FftField> {
     // -----------------------------------
     /// EC point addition constraint selector polynomial
     #[serde_as(as = "o1_utils::serialization::SerdeAs")]
-    pub addm: DP<F>,
-    /// EC point doubling constraint selector polynomial
-    #[serde_as(as = "o1_utils::serialization::SerdeAs")]
-    pub doublem: DP<F>,
+    pub complete_addm: DP<F>,
     /// mulm constraint selector polynomial
     #[serde_as(as = "o1_utils::serialization::SerdeAs")]
     pub mulm: DP<F>,
@@ -110,15 +107,9 @@ pub struct ConstraintSystem<F: FftField> {
 
     // ECC arithmetic selector polynomials
     // -----------------------------------
-    /// EC point addition selector evaluations w over domain.d4
-    #[serde_as(as = "o1_utils::serialization::SerdeAs")]
-    pub addl: E<F, D<F>>,
-    /// EC point doubling selector evaluations w over domain.d8
-    #[serde_as(as = "o1_utils::serialization::SerdeAs")]
-    pub doubl8: E<F, D<F>>,
-    /// EC point doubling selector evaluations w over domain.d4
+    /// EC point addition selector evaluations w over domain.d2
     #[serde_as(as = "o1_utils::serialization::SerdeAs")]
-    pub doubl4: E<F, D<F>>,
+    pub complete_addl4: E<F, D<F>>,
     /// scalar multiplication selector evaluations over domain.d8
     #[serde_as(as = "o1_utils::serialization::SerdeAs")]
     pub mull8: E<F, D<F>>,
@@ -330,13 +321,8 @@ impl<F: FftField + SquareRootField> ConstraintSystem<F> {
         .interpolate();
 
         // compute ECC arithmetic constraint polynomials
-        let addm = E::<F, D<F>>::from_vec_and_domain(
-            gates.iter().map(|gate| gate.add()).collect(),
-            domain.d1,
-        )
-        .interpolate();
-        let doublem = E::<F, D<F>>::from_vec_and_domain(
-            gates.iter().map(|gate| gate.double()).collect(),
+        let complete_addm = E::<F, D<F>>::from_vec_and_domain(
+            gates.iter().map(|gate| F::from((gate.typ == GateType::CompleteAdd) as u64)).collect(),
             domain.d1,
         )
         .interpolate();
@@ -423,11 +409,9 @@ impl<F: FftField + SquareRootField> ConstraintSystem<F> {
         let ps8 = psm.evaluate_over_domain_by_ref(domain.d8);
 
         // ECC arithmetic constraint polynomials
-        let addl = addm.evaluate_over_domain_by_ref(domain.d4);
-        let doubl8 = doublem.evaluate_over_domain_by_ref(domain.d8);
-        let doubl4 = doublem.evaluate_over_domain_by_ref(domain.d4);
         let mull8 = mulm.evaluate_over_domain_by_ref(domain.d8);
         let emull = emulm.evaluate_over_domain_by_ref(domain.d8);
+        let complete_addl4 = complete_addm.evaluate_over_domain_by_ref(domain.d4);
 
         // constant polynomials
         let l1 = DP::from_coefficients_slice(&[F::zero(), F::one()])
@@ -497,11 +481,8 @@ impl<F: FftField + SquareRootField> ConstraintSystem<F> {
             coefficients8,
             ps8,
             psm,
-            addl,
-            addm,
-            doubl8,
-            doubl4,
-            doublem,
+            complete_addm,
+            complete_addl4,
             mull8,
             mulm,
             emull,