logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-05 07:13:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

s/ext_ext/ext_algebra

Browse Source
This commit is contained in:
wborgeaud 2021-06-08 11:30:39 +02:00
parent d727f84a56
commit 070dc7c9f1
5 changed files with 50 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/field/extension_field/algebra.rs
View File

@ -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};

56
src/field/extension_field/target.rs
View File

@ -15,9 +15,9 @@ impl<const D: usize> ExtensionTarget<D> {
/// `Target`s representing an element of an extension of an extension field.
#[derive(Copy, Clone, Debug)]
pub struct ExtensionExtensionTarget<const D: usize>(pub [ExtensionTarget<D>; D]);
pub struct ExtensionAlgebraTarget<const D: usize>(pub [ExtensionTarget<D>; D]);
impl<const D: usize> ExtensionExtensionTarget<D> {
impl<const D: usize> ExtensionAlgebraTarget<D> {
pub fn to_ext_target_array(&self) -> [ExtensionTarget<D>; D] {
self.0
}
@ -33,10 +33,10 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
ExtensionTarget(parts)
}
pub fn constant_ext_ext(
pub fn constant_ext_algebra(
&mut self,
c: <<F as Extendable<D>>::Extension as Extendable<D>>::Extension,
) -> ExtensionExtensionTarget<D>
) -> ExtensionAlgebraTarget<D>
where
F::Extension: Extendable<D>,
{
@ -45,7 +45,7 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
for i in 0..D {
parts[i] = self.constant_extension(c_parts[i]);
}
ExtensionExtensionTarget(parts)
ExtensionAlgebraTarget(parts)
}
pub fn zero_extension(&mut self) -> ExtensionTarget<D> {
@ -60,11 +60,13 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
self.constant_extension(F::Extension::TWO)
}
pub fn zero_ext_ext(&mut self) -> ExtensionExtensionTarget<D>
pub fn zero_ext_algebra(&mut self) -> ExtensionAlgebraTarget<D>
where
F::Extension: Extendable<D>,
{
self.constant_ext_ext(<<F as Extendable<D>>::Extension as Extendable<D>>::Extension::ZERO)
self.constant_ext_algebra(
<<F as Extendable<D>>::Extension as Extendable<D>>::Extension::ZERO,
)
}
pub fn add_extension(
@ -78,11 +80,11 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
a
}
pub fn add_ext_ext(
pub fn add_ext_algebra(
&mut self,
mut a: ExtensionExtensionTarget<D>,
b: ExtensionExtensionTarget<D>,
) -> ExtensionExtensionTarget<D> {
mut a: ExtensionAlgebraTarget<D>,
b: ExtensionAlgebraTarget<D>,
) -> ExtensionAlgebraTarget<D> {
for i in 0..D {
a.0[i] = self.add_extension(a.0[i], b.0[i]);
}
@ -108,11 +110,11 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
a
}
pub fn sub_ext_ext(
pub fn sub_ext_algebra(
&mut self,
mut a: ExtensionExtensionTarget<D>,
b: ExtensionExtensionTarget<D>,
) -> ExtensionExtensionTarget<D> {
mut a: ExtensionAlgebraTarget<D>,
b: ExtensionAlgebraTarget<D>,
) -> ExtensionAlgebraTarget<D> {
for i in 0..D {
a.0[i] = self.sub_extension(a.0[i], b.0[i]);
}
@ -138,29 +140,25 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
ExtensionTarget(res)
}
pub fn mul_ext_ext(
pub fn mul_ext_algebra(
&mut self,
mut a: ExtensionExtensionTarget<D>,
b: ExtensionExtensionTarget<D>,
) -> ExtensionExtensionTarget<D>
where
F::Extension: Extendable<D>,
{
mut a: ExtensionAlgebraTarget<D>,
b: ExtensionAlgebraTarget<D>,
) -> ExtensionAlgebraTarget<D> {
let mut res = [self.zero_extension(); D];
let w = self
.constant_extension(<<F as Extendable<D>>::Extension as Extendable<D>>::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<D>]) -> ExtensionTarget<D> {
@ -193,11 +191,11 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// 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<D>,
mut b: ExtensionExtensionTarget<D>,
) -> ExtensionExtensionTarget<D>
mut b: ExtensionAlgebraTarget<D>,
) -> ExtensionAlgebraTarget<D>
where
F::Extension: Extendable<D>,
{

22
src/gadgets/polynomial.rs
View File

@ -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<const D: usize> PolynomialCoeffsExtTarget<D> {
}
}
pub struct PolynomialCoeffsExtExtTarget<const D: usize>(pub Vec<ExtensionExtensionTarget<D>>);
pub struct PolynomialCoeffsExtExtTarget<const D: usize>(pub Vec<ExtensionAlgebraTarget<D>>);
impl<const D: usize> PolynomialCoeffsExtExtTarget<D> {
pub fn eval_scalar<F>(
&self,
builder: &mut CircuitBuilder<F, D>,
point: ExtensionTarget<D>,
) -> ExtensionExtensionTarget<D>
) -> ExtensionAlgebraTarget<D>
where
F: Extendable<D>,
F::Extension: Extendable<D>,
{
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<const D: usize> PolynomialCoeffsExtExtTarget<D> {
pub fn eval<F>(
&self,
builder: &mut CircuitBuilder<F, D>,
point: ExtensionExtensionTarget<D>,
) -> ExtensionExtensionTarget<D>
point: ExtensionAlgebraTarget<D>,
) -> ExtensionAlgebraTarget<D>
where
F: Extendable<D>,
F::Extension: Extendable<D>,
{
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
}

15
src/gates/interpolation.rs
View File

@ -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::<Vec<_>>()
}
/// 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();

8
src/vars.rs
View File

@ -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<usize>) -> ExtensionExtensionTarget<D> {
pub fn get_local_ext_algebra(&self, wire_range: Range<usize>) -> ExtensionAlgebraTarget<D> {
debug_assert_eq!(wire_range.len(), D);
let arr = self.local_wires[wire_range].try_into().unwrap();
ExtensionExtensionTarget(arr)
ExtensionAlgebraTarget(arr)
}
}