From 070dc7c9f1bb81982e7910e380867d69fdd287b6 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Tue, 8 Jun 2021 11:30:39 +0200 Subject: [PATCH] s/ext_ext/ext_algebra --- src/field/extension_field/algebra.rs | 2 +- src/field/extension_field/target.rs | 56 ++++++++++++++-------------- src/gadgets/polynomial.rs | 22 +++++------ src/gates/interpolation.rs | 15 ++++---- src/vars.rs | 8 ++-- 5 files changed, 50 insertions(+), 53 deletions(-) diff --git a/src/field/extension_field/algebra.rs b/src/field/extension_field/algebra.rs index 7a4f43a3..1cddb4c1 100644 --- a/src/field/extension_field/algebra.rs +++ b/src/field/extension_field/algebra.rs @@ -1,4 +1,4 @@ -use crate::field::extension_field::{FieldExtension, OEF}; +use crate::field::extension_field::OEF; use std::fmt::{Debug, Display, Formatter}; use std::iter::{Product, Sum}; use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign}; diff --git a/src/field/extension_field/target.rs b/src/field/extension_field/target.rs index 7198ebf6..d4603cbb 100644 --- a/src/field/extension_field/target.rs +++ b/src/field/extension_field/target.rs @@ -15,9 +15,9 @@ impl ExtensionTarget { /// `Target`s representing an element of an extension of an extension field. #[derive(Copy, Clone, Debug)] -pub struct ExtensionExtensionTarget(pub [ExtensionTarget; D]); +pub struct ExtensionAlgebraTarget(pub [ExtensionTarget; D]); -impl ExtensionExtensionTarget { +impl ExtensionAlgebraTarget { pub fn to_ext_target_array(&self) -> [ExtensionTarget; D] { self.0 } @@ -33,10 +33,10 @@ impl, const D: usize> CircuitBuilder { ExtensionTarget(parts) } - pub fn constant_ext_ext( + pub fn constant_ext_algebra( &mut self, c: <>::Extension as Extendable>::Extension, - ) -> ExtensionExtensionTarget + ) -> ExtensionAlgebraTarget where F::Extension: Extendable, { @@ -45,7 +45,7 @@ impl, const D: usize> CircuitBuilder { for i in 0..D { parts[i] = self.constant_extension(c_parts[i]); } - ExtensionExtensionTarget(parts) + ExtensionAlgebraTarget(parts) } pub fn zero_extension(&mut self) -> ExtensionTarget { @@ -60,11 +60,13 @@ impl, const D: usize> CircuitBuilder { self.constant_extension(F::Extension::TWO) } - pub fn zero_ext_ext(&mut self) -> ExtensionExtensionTarget + pub fn zero_ext_algebra(&mut self) -> ExtensionAlgebraTarget where F::Extension: Extendable, { - self.constant_ext_ext(<>::Extension as Extendable>::Extension::ZERO) + self.constant_ext_algebra( + <>::Extension as Extendable>::Extension::ZERO, + ) } pub fn add_extension( @@ -78,11 +80,11 @@ impl, const D: usize> CircuitBuilder { a } - pub fn add_ext_ext( + pub fn add_ext_algebra( &mut self, - mut a: ExtensionExtensionTarget, - b: ExtensionExtensionTarget, - ) -> ExtensionExtensionTarget { + mut a: ExtensionAlgebraTarget, + b: ExtensionAlgebraTarget, + ) -> ExtensionAlgebraTarget { for i in 0..D { a.0[i] = self.add_extension(a.0[i], b.0[i]); } @@ -108,11 +110,11 @@ impl, const D: usize> CircuitBuilder { a } - pub fn sub_ext_ext( + pub fn sub_ext_algebra( &mut self, - mut a: ExtensionExtensionTarget, - b: ExtensionExtensionTarget, - ) -> ExtensionExtensionTarget { + mut a: ExtensionAlgebraTarget, + b: ExtensionAlgebraTarget, + ) -> ExtensionAlgebraTarget { for i in 0..D { a.0[i] = self.sub_extension(a.0[i], b.0[i]); } @@ -138,29 +140,25 @@ impl, const D: usize> CircuitBuilder { ExtensionTarget(res) } - pub fn mul_ext_ext( + pub fn mul_ext_algebra( &mut self, - mut a: ExtensionExtensionTarget, - b: ExtensionExtensionTarget, - ) -> ExtensionExtensionTarget - where - F::Extension: Extendable, - { + mut a: ExtensionAlgebraTarget, + b: ExtensionAlgebraTarget, + ) -> ExtensionAlgebraTarget { let mut res = [self.zero_extension(); D]; - let w = self - .constant_extension(<>::Extension as Extendable>::Extension::W); + let w = self.constant(F::Extension::W); for i in 0..D { for j in 0..D { let ai_bi = self.mul_extension(a.0[i], b.0[j]); res[(i + j) % D] = if i + j < D { self.add_extension(ai_bi, res[(i + j) % D]) } else { - let w_ai_bi = self.mul_extension(w, ai_bi); + let w_ai_bi = self.scalar_mul_ext(w, ai_bi); self.add_extension(w_ai_bi, res[(i + j) % D]) } } } - ExtensionExtensionTarget(res) + ExtensionAlgebraTarget(res) } pub fn mul_many_extension(&mut self, terms: &[ExtensionTarget]) -> ExtensionTarget { @@ -193,11 +191,11 @@ impl, const D: usize> CircuitBuilder { /// Returns `a * b`, where `b` is in the extension of the extension field, and `a` is in the /// extension field. - pub fn scalar_mul_ext_ext( + pub fn scalar_mul_ext_algebra( &mut self, a: ExtensionTarget, - mut b: ExtensionExtensionTarget, - ) -> ExtensionExtensionTarget + mut b: ExtensionAlgebraTarget, + ) -> ExtensionAlgebraTarget where F::Extension: Extendable, { diff --git a/src/gadgets/polynomial.rs b/src/gadgets/polynomial.rs index cac51452..8037f287 100644 --- a/src/gadgets/polynomial.rs +++ b/src/gadgets/polynomial.rs @@ -1,5 +1,5 @@ use crate::circuit_builder::CircuitBuilder; -use crate::field::extension_field::target::{ExtensionExtensionTarget, ExtensionTarget}; +use crate::field::extension_field::target::{ExtensionAlgebraTarget, ExtensionTarget}; use crate::field::extension_field::Extendable; use crate::target::Target; @@ -33,22 +33,22 @@ impl PolynomialCoeffsExtTarget { } } -pub struct PolynomialCoeffsExtExtTarget(pub Vec>); +pub struct PolynomialCoeffsExtExtTarget(pub Vec>); impl PolynomialCoeffsExtExtTarget { pub fn eval_scalar( &self, builder: &mut CircuitBuilder, point: ExtensionTarget, - ) -> ExtensionExtensionTarget + ) -> ExtensionAlgebraTarget where F: Extendable, F::Extension: Extendable, { - let mut acc = builder.zero_ext_ext(); + let mut acc = builder.zero_ext_algebra(); for &c in self.0.iter().rev() { - let tmp = builder.scalar_mul_ext_ext(point, acc); - acc = builder.add_ext_ext(tmp, c); + let tmp = builder.scalar_mul_ext_algebra(point, acc); + acc = builder.add_ext_algebra(tmp, c); } acc } @@ -56,16 +56,16 @@ impl PolynomialCoeffsExtExtTarget { pub fn eval( &self, builder: &mut CircuitBuilder, - point: ExtensionExtensionTarget, - ) -> ExtensionExtensionTarget + point: ExtensionAlgebraTarget, + ) -> ExtensionAlgebraTarget where F: Extendable, F::Extension: Extendable, { - let mut acc = builder.zero_ext_ext(); + let mut acc = builder.zero_ext_algebra(); for &c in self.0.iter().rev() { - let tmp = builder.mul_ext_ext(point, acc); - acc = builder.add_ext_ext(tmp, c); + let tmp = builder.mul_ext_algebra(point, acc); + acc = builder.add_ext_algebra(tmp, c); } acc } diff --git a/src/gates/interpolation.rs b/src/gates/interpolation.rs index 804b9310..0d3b8666 100644 --- a/src/gates/interpolation.rs +++ b/src/gates/interpolation.rs @@ -10,7 +10,6 @@ use crate::field::lagrange::interpolant; use crate::gadgets::polynomial::PolynomialCoeffsExtExtTarget; use crate::gates::gate::{Gate, GateRef}; use crate::generator::{SimpleGenerator, WitnessGenerator}; -use crate::polynomial::polynomial::PolynomialCoeffs; use crate::target::Target; use crate::vars::{EvaluationTargets, EvaluationVars}; use crate::wire::Wire; @@ -139,27 +138,27 @@ where let mut constraints = Vec::with_capacity(self.num_constraints()); let coeffs = (0..self.num_points) - .map(|i| vars.get_local_ext_ext(self.wires_coeff(i))) + .map(|i| vars.get_local_ext_algebra(self.wires_coeff(i))) .collect(); let interpolant = PolynomialCoeffsExtExtTarget(coeffs); for i in 0..self.num_points { let point = vars.local_wires[self.wire_point(i)]; - let value = vars.get_local_ext_ext(self.wires_value(i)); + let value = vars.get_local_ext_algebra(self.wires_value(i)); let computed_value = interpolant.eval_scalar(builder, point); constraints.extend( &builder - .sub_ext_ext(value, computed_value) + .sub_ext_algebra(value, computed_value) .to_ext_target_array(), ); } - let evaluation_point = vars.get_local_ext_ext(self.wires_evaluation_point()); - let evaluation_value = vars.get_local_ext_ext(self.wires_evaluation_value()); + let evaluation_point = vars.get_local_ext_algebra(self.wires_evaluation_point()); + let evaluation_value = vars.get_local_ext_algebra(self.wires_evaluation_value()); let computed_evaluation_value = interpolant.eval(builder, evaluation_point); constraints.extend( &builder - .sub_ext_ext(evaluation_value, computed_evaluation_value) + .sub_ext_algebra(evaluation_value, computed_evaluation_value) .to_ext_target_array(), ); @@ -359,7 +358,7 @@ mod tests { v.iter().map(|&x| x.into()).collect::>() } - /// Get a working row for InterpolationGate. + // Get a working row for InterpolationGate. let coeffs = PolynomialCoeffs::new(vec![FF::rand(), FF::rand()]); let points = vec![F::rand(), F::rand()]; let eval_point = FF::rand(); diff --git a/src/vars.rs b/src/vars.rs index 1ac7935c..74f15f23 100644 --- a/src/vars.rs +++ b/src/vars.rs @@ -2,8 +2,8 @@ use std::convert::TryInto; use std::ops::Range; use crate::field::extension_field::algebra::ExtensionAlgebra; -use crate::field::extension_field::target::{ExtensionExtensionTarget, ExtensionTarget}; -use crate::field::extension_field::{Extendable, FieldExtension}; +use crate::field::extension_field::target::{ExtensionAlgebraTarget, ExtensionTarget}; +use crate::field::extension_field::Extendable; use crate::field::field::Field; #[derive(Copy, Clone)] @@ -36,9 +36,9 @@ pub struct EvaluationTargets<'a, const D: usize> { } impl<'a, const D: usize> EvaluationTargets<'a, D> { - pub fn get_local_ext_ext(&self, wire_range: Range) -> ExtensionExtensionTarget { + pub fn get_local_ext_algebra(&self, wire_range: Range) -> ExtensionAlgebraTarget { debug_assert_eq!(wire_range.len(), D); let arr = self.local_wires[wire_range].try_into().unwrap(); - ExtensionExtensionTarget(arr) + ExtensionAlgebraTarget(arr) } }