logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-16 12:43:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Split into crates (#406)

Browse Source 
* Split into crates

I kept other changes to a minimum, so 95% of this is just moving things. One complication that came up is that since `PrimeField` is now outside the plonky2 crate, these two impls now conflict:
```
impl<F: PrimeField> From<HashOut<F>> for Vec<u8> { ... }
impl<F: PrimeField> From<HashOut<F>> for Vec<F> { ... }
```
with this note:
```
note: upstream crates may add a new impl of trait `plonky2_field::field_types::PrimeField` for type `u8` in future versions
```
I worked around this by adding a `GenericHashOut` trait with methods like `to_bytes()` instead of overloading `From`/`Into`. Personally I prefer the explicitness anyway.

* Move out permutation network stuff also

* Fix imports

* Fix import

* Also move out insertion

* Comment

* fmt

* PR feedback
This commit is contained in:
Daniel Lubarov 2021-12-28 11:51:13 -08:00 committed by GitHub
parent 107ba3ab05
commit c126641c5d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
149 changed files with 1686 additions and 1320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
Cargo.toml
View File

@ -1,60 +1,2 @@
[package]
name = "plonky2"
description = "Recursive SNARKs based on Plonk and FRI"
version = "0.1.0"
authors = ["Daniel Lubarov <daniel@mirprotocol.org>"]
readme = "README.md"
license = "MIT OR Apache-2.0"
repository = "https://github.com/mir-protocol/plonky2"
keywords = ["cryptography", "SNARK", "FRI"]
categories = ["cryptography"]
edition = "2021"
default-run = "bench_recursion"
[dependencies]
array_tool = "1.0.3"
bimap = "0.6.1"
env_logger = "0.9.0"
log = "0.4.14"
itertools = "0.10.0"
num = { version = "0.4", features = [ "rand" ] }
rand = "0.8.4"
rand_chacha = "0.3.1"
rayon = "1.5.1"
unroll = "0.1.5"
anyhow = "1.0.40"
serde = { version = "1.0", features = ["derive"] }
serde_cbor = "0.11.1"
keccak-hash = "0.8.0"
static_assertions = "1.1.0"
[target.'cfg(not(target_env = "msvc"))'.dependencies]
jemallocator = "0.3.2"
[dev-dependencies]
criterion = "0.3.5"
tynm = "0.1.6"
[[bench]]
name = "field_arithmetic"
harness = false
[[bench]]
name = "ffts"
harness = false
[[bench]]
name = "hashing"
harness = false
[[bench]]
name = "transpose"
harness = false
[profile.release]
opt-level = 3
#lto = "fat"
#codegen-units = 1
[profile.bench]
opt-level = 3
[workspace]
members = ["field", "insertion", "plonky2", "util", "waksman"]

13
field/Cargo.toml Normal file
View File

@ -0,0 +1,13 @@
[package]
name = "plonky2_field"
version = "0.1.0"
edition = "2021"
[dependencies]
plonky2_util = { path = "../util" }
anyhow = "1.0.40"
itertools = "0.10.0"
num = { version = "0.4", features = [ "rand" ] }
rand = "0.8.4"
serde = { version = "1.0", features = ["derive"] }
unroll = "0.1.5"

0
src/field/arch/mod.rs → field/src/arch/mod.rs
View File

14
src/field/arch/x86_64/avx2_goldilocks_field.rs → field/src/arch/x86_64/avx2_goldilocks_field.rs
View File

@ -5,9 +5,9 @@ use std::iter::{Product, Sum};
use std::mem::transmute;
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
use crate::field::field_types::{Field, PrimeField};
use crate::field::goldilocks_field::GoldilocksField;
use crate::field::packed_field::PackedField;
use crate::field_types::{Field, PrimeField};
use crate::goldilocks_field::GoldilocksField;
use crate::packed_field::PackedField;
// Ideally `Avx2GoldilocksField` would wrap `__m256i`. Unfortunately, `__m256i` has an alignment of
// 32B, which would preclude us from casting `[GoldilocksField; 4]` (alignment 8B) to
@ -506,10 +506,10 @@ unsafe fn interleave2(x: __m256i, y: __m256i) -> (__m256i, __m256i) {
#[cfg(test)]
mod tests {
use crate::field::arch::x86_64::avx2_goldilocks_field::Avx2GoldilocksField;
use crate::field::field_types::PrimeField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::field::packed_field::PackedField;
use crate::arch::x86_64::avx2_goldilocks_field::Avx2GoldilocksField;
use crate::field_types::PrimeField;
use crate::goldilocks_field::GoldilocksField;
use crate::packed_field::PackedField;
fn test_vals_a() -> [GoldilocksField; 4] {
[

0
src/field/arch/x86_64/mod.rs → field/src/arch/x86_64/mod.rs
View File

6
src/field/batch_util.rs → field/src/batch_util.rs
View File

@ -1,6 +1,6 @@
use crate::field::field_types::Field;
use crate::field::packable::Packable;
use crate::field::packed_field::PackedField;
use crate::field_types::Field;
use crate::packable::Packable;
use crate::packed_field::PackedField;
fn pack_with_leftovers_split_point<P: PackedField>(slice: &[P::Scalar]) -> usize {
let n = slice.len();

10
src/field/cosets.rs → field/src/cosets.rs
View File

@ -1,10 +1,10 @@
use num::bigint::BigUint;
use crate::field::field_types::Field;
use crate::field_types::Field;
/// Finds a set of shifts that result in unique cosets for the multiplicative subgroup of size
/// `2^subgroup_bits`.
pub(crate) fn get_unique_coset_shifts<F: Field>(subgroup_size: usize, num_shifts: usize) -> Vec<F> {
pub fn get_unique_coset_shifts<F: Field>(subgroup_size: usize, num_shifts: usize) -> Vec<F> {
// From Lagrange's theorem.
let num_cosets = (F::order() - 1u32) / (subgroup_size as u32);
assert!(
@ -25,9 +25,9 @@ pub(crate) fn get_unique_coset_shifts<F: Field>(subgroup_size: usize, num_shifts
mod tests {
use std::collections::HashSet;
use crate::field::cosets::get_unique_coset_shifts;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::cosets::get_unique_coset_shifts;
use crate::field_types::Field;
use crate::goldilocks_field::GoldilocksField;
#[test]
fn distinct_cosets() {

10
src/field/extension_field/algebra.rs → field/src/extension_field/algebra.rs
View File

@ -2,7 +2,7 @@ use std::fmt::{Debug, Display, Formatter};
use std::iter::{Product, Sum};
use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
use crate::field::extension_field::OEF;
use crate::extension_field::OEF;
/// Let `F_D` be the optimal extension field `F[X]/(X^D-W)`. Then `ExtensionAlgebra<F_D>` is the quotient `F_D[X]/(X^D-W)`.
/// It's a `D`-dimensional algebra over `F_D` useful to lift the multiplication over `F_D` to a multiplication over `(F_D)^D`.
@ -192,10 +192,10 @@ impl<F: OEF<D>, const D: usize> PolynomialCoeffsAlgebra<F, D> {
mod tests {
use itertools::Itertools;
use crate::field::extension_field::algebra::ExtensionAlgebra;
use crate::field::extension_field::{Extendable, FieldExtension};
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::extension_field::algebra::ExtensionAlgebra;
use crate::extension_field::{Extendable, FieldExtension};
use crate::field_types::Field;
use crate::goldilocks_field::GoldilocksField;
/// Tests that the multiplication on the extension algebra lifts that of the field extension.
fn test_extension_algebra<F: Extendable<D>, const D: usize>() {

7
src/field/extension_field/mod.rs → field/src/extension_field/mod.rs
View File

@ -1,11 +1,10 @@
use std::convert::TryInto;
use crate::field::field_types::{Field, RichField};
use crate::field_types::Field;
pub mod algebra;
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`,
@ -61,7 +60,7 @@ pub trait Frobenius<const D: usize>: OEF<D> {
}
}
pub trait Extendable<const D: usize>: RichField + Sized {
pub trait Extendable<const D: usize>: Field + Sized {
type Extension: Field + OEF<D, BaseField = Self> + Frobenius<D> + From<Self>;
const W: Self;
@ -76,7 +75,7 @@ pub trait Extendable<const D: usize>: RichField + Sized {
const EXT_POWER_OF_TWO_GENERATOR: [Self; D];
}
impl<F: RichField + Frobenius<1> + FieldExtension<1, BaseField = F>> Extendable<1> for F {
impl<F: Field + Frobenius<1> + FieldExtension<1, BaseField = F>> Extendable<1> for F {
type Extension = F;
const W: Self = F::ZERO;
const DTH_ROOT: Self = F::ZERO;

12
src/field/extension_field/quadratic.rs → field/src/extension_field/quadratic.rs
View File

@ -7,12 +7,12 @@ use num::Integer;
use rand::Rng;
use serde::{Deserialize, Serialize};
use crate::field::extension_field::{Extendable, FieldExtension, Frobenius, OEF};
use crate::field::field_types::Field;
use crate::extension_field::{Extendable, FieldExtension, Frobenius, OEF};
use crate::field_types::Field;
#[derive(Copy, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(bound = "")]
pub struct QuadraticExtension<F: Extendable<2>>(pub(crate) [F; 2]);
pub struct QuadraticExtension<F: Extendable<2>>(pub [F; 2]);
impl<F: Extendable<2>> Default for QuadraticExtension<F> {
fn default() -> Self {
@ -230,10 +230,10 @@ mod tests {
mod goldilocks {
use crate::{test_field_arithmetic, test_field_extension};
test_field_extension!(crate::field::goldilocks_field::GoldilocksField, 2);
test_field_extension!(crate::goldilocks_field::GoldilocksField, 2);
test_field_arithmetic!(
crate::field::extension_field::quadratic::QuadraticExtension<
crate::field::goldilocks_field::GoldilocksField,
crate::extension_field::quadratic::QuadraticExtension<
crate::goldilocks_field::GoldilocksField,
>
);
}

12
src/field/extension_field/quartic.rs → field/src/extension_field/quartic.rs
View File

@ -8,12 +8,12 @@ use num::Integer;
use rand::Rng;
use serde::{Deserialize, Serialize};
use crate::field::extension_field::{Extendable, FieldExtension, Frobenius, OEF};
use crate::field::field_types::Field;
use crate::extension_field::{Extendable, FieldExtension, Frobenius, OEF};
use crate::field_types::Field;
#[derive(Copy, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(bound = "")]
pub struct QuarticExtension<F: Extendable<4>>(pub(crate) [F; 4]);
pub struct QuarticExtension<F: Extendable<4>>(pub [F; 4]);
impl<F: Extendable<4>> Default for QuarticExtension<F> {
fn default() -> Self {
@ -267,10 +267,10 @@ mod tests {
mod goldilocks {
use crate::{test_field_arithmetic, test_field_extension};
test_field_extension!(crate::field::goldilocks_field::GoldilocksField, 4);
test_field_extension!(crate::goldilocks_field::GoldilocksField, 4);
test_field_arithmetic!(
crate::field::extension_field::quartic::QuarticExtension<
crate::field::goldilocks_field::GoldilocksField,
crate::extension_field::quartic::QuarticExtension<
crate::goldilocks_field::GoldilocksField,
>
);
}

19
src/field/fft.rs → field/src/fft.rs
View File

@ -1,15 +1,15 @@
use std::cmp::{max, min};
use std::option::Option;
use plonky2_util::{log2_strict, reverse_index_bits};
use unroll::unroll_for_loops;
use crate::field::field_types::Field;
use crate::field::packable::Packable;
use crate::field::packed_field::PackedField;
use crate::field_types::Field;
use crate::packable::Packable;
use crate::packed_field::PackedField;
use crate::polynomial::{PolynomialCoeffs, PolynomialValues};
use crate::util::{log2_strict, reverse_index_bits};
pub(crate) type FftRootTable<F> = Vec<Vec<F>>;
pub type FftRootTable<F> = Vec<Vec<F>>;
pub fn fft_root_table<F: Field>(n: usize) -> FftRootTable<F> {
let lg_n = log2_strict(n);
@ -209,11 +209,12 @@ pub(crate) fn fft_classic<F: Field>(input: &[F], r: usize, root_table: &FftRootT
#[cfg(test)]
mod tests {
use crate::field::fft::{fft, fft_with_options, ifft};
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use plonky2_util::{log2_ceil, log2_strict};
use crate::fft::{fft, fft_with_options, ifft};
use crate::field_types::Field;
use crate::goldilocks_field::GoldilocksField;
use crate::polynomial::{PolynomialCoeffs, PolynomialValues};
use crate::util::{log2_ceil, log2_strict};
#[test]
fn fft_and_ifft() {

18
src/field/field_testing.rs → field/src/field_testing.rs
View File

@ -1,6 +1,6 @@
use crate::field::extension_field::Extendable;
use crate::field::extension_field::Frobenius;
use crate::field::field_types::Field;
use crate::extension_field::Extendable;
use crate::extension_field::Frobenius;
use crate::field_types::Field;
#[macro_export]
macro_rules! test_field_arithmetic {
@ -9,7 +9,7 @@ macro_rules! test_field_arithmetic {
use num::bigint::BigUint;
use rand::Rng;
use crate::field::field_types::Field;
use crate::field_types::Field;
#[test]
fn batch_inversion() {
@ -168,23 +168,23 @@ macro_rules! test_field_extension {
mod field_extension {
#[test]
fn test_add_neg_sub_mul() {
crate::field::field_testing::test_add_neg_sub_mul::<$field, $d>();
crate::field_testing::test_add_neg_sub_mul::<$field, $d>();
}
#[test]
fn test_inv_div() {
crate::field::field_testing::test_inv_div::<$field, $d>();
crate::field_testing::test_inv_div::<$field, $d>();
}
#[test]
fn test_frobenius() {
crate::field::field_testing::test_frobenius::<$field, $d>();
crate::field_testing::test_frobenius::<$field, $d>();
}
#[test]
fn test_field_order() {
crate::field::field_testing::test_field_order::<$field, $d>();
crate::field_testing::test_field_order::<$field, $d>();
}
#[test]
fn test_power_of_two_gen() {
crate::field::field_testing::test_power_of_two_gen::<$field, $d>();
crate::field_testing::test_power_of_two_gen::<$field, $d>();
}
}
};

9
src/field/field_types.rs → field/src/field_types.rs
View File

@ -5,17 +5,12 @@ use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssi
use num::bigint::BigUint;
use num::{Integer, One, ToPrimitive, Zero};
use plonky2_util::bits_u64;
use rand::Rng;
use serde::de::DeserializeOwned;
use serde::Serialize;
use crate::field::extension_field::Frobenius;
use crate::hash::gmimc::GMiMC;
use crate::hash::poseidon::Poseidon;
use crate::util::bits_u64;
/// A prime order field with the features we need to use it as a base field in our argument system.
pub trait RichField: PrimeField + GMiMC<12> + Poseidon {}
use crate::extension_field::Frobenius;
/// A finite field.
pub trait Field:

18
src/field/goldilocks_field.rs → field/src/goldilocks_field.rs
View File

@ -5,15 +5,15 @@ use std::iter::{Product, Sum};
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
use num::{BigUint, Integer};
use plonky2_util::{assume, branch_hint};
use rand::Rng;
use serde::{Deserialize, Serialize};
use crate::field::extension_field::quadratic::QuadraticExtension;
use crate::field::extension_field::quartic::QuarticExtension;
use crate::field::extension_field::{Extendable, Frobenius};
use crate::field::field_types::{Field, PrimeField, RichField};
use crate::field::inversion::try_inverse_u64;
use crate::util::{assume, branch_hint};
use crate::extension_field::quadratic::QuadraticExtension;
use crate::extension_field::quartic::QuarticExtension;
use crate::extension_field::{Extendable, Frobenius};
use crate::field_types::{Field, PrimeField};
use crate::inversion::try_inverse_u64;
const EPSILON: u64 = (1 << 32) - 1;
@ -313,8 +313,6 @@ impl Extendable<4> for GoldilocksField {
[Self(0), Self(0), Self(0), Self(12587610116473453104)];
}
impl RichField for GoldilocksField {}
/// Fast addition modulo ORDER for x86-64.
/// This function is marked unsafe for the following reasons:
/// - It is only correct if x + y < 2**64 + ORDER = 0x1ffffffff00000001.
@ -385,6 +383,6 @@ impl Frobenius<1> for GoldilocksField {}
mod tests {
use crate::{test_field_arithmetic, test_prime_field_arithmetic};
test_prime_field_arithmetic!(crate::field::goldilocks_field::GoldilocksField);
test_field_arithmetic!(crate::field::goldilocks_field::GoldilocksField);
test_prime_field_arithmetic!(crate::goldilocks_field::GoldilocksField);
test_field_arithmetic!(crate::goldilocks_field::GoldilocksField);
}

15
src/field/interpolation.rs → field/src/interpolation.rs
View File

@ -1,13 +1,14 @@
use crate::field::fft::ifft;
use crate::field::field_types::Field;
use plonky2_util::log2_ceil;
use crate::fft::ifft;
use crate::field_types::Field;
use crate::polynomial::{PolynomialCoeffs, PolynomialValues};
use crate::util::log2_ceil;
/// Computes the unique degree < n interpolant of an arbitrary list of n (point, value) pairs.
///
/// Note that the implementation assumes that `F` is two-adic, in particular that
/// `2^{F::TWO_ADICITY} >= points.len()`. This leads to a simple FFT-based implementation.
pub(crate) fn interpolant<F: Field>(points: &[(F, F)]) -> PolynomialCoeffs<F> {
pub fn interpolant<F: Field>(points: &[(F, F)]) -> PolynomialCoeffs<F> {
let n = points.len();
let n_log = log2_ceil(n);
@ -77,9 +78,9 @@ pub fn interpolate2<F: Field>(points: [(F, F); 2], x: F) -> F {
#[cfg(test)]
mod tests {
use super::*;
use crate::field::extension_field::quartic::QuarticExtension;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::extension_field::quartic::QuarticExtension;
use crate::field_types::Field;
use crate::goldilocks_field::GoldilocksField;
use crate::polynomial::PolynomialCoeffs;
#[test]

2
src/field/inversion.rs → field/src/inversion.rs
View File

@ -1,4 +1,4 @@
use crate::field::field_types::PrimeField;
use crate::field_types::PrimeField;
/// This is a 'safe' iteration for the modular inversion algorithm. It
/// is safe in the sense that it will produce the right answer even

29
field/src/lib.rs Normal file
View File

@ -0,0 +1,29 @@
#![allow(incomplete_features)]
#![allow(clippy::new_without_default)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::type_complexity)]
#![allow(clippy::len_without_is_empty)]
#![allow(clippy::needless_range_loop)]
#![allow(clippy::return_self_not_must_use)]
#![feature(generic_const_exprs)]
#![feature(specialization)]
pub(crate) mod arch;
pub mod batch_util;
pub mod cosets;
pub mod extension_field;
pub mod fft;
pub mod field_types;
pub mod goldilocks_field;
pub mod interpolation;
mod inversion;
pub mod packable;
pub mod packed_field;
pub mod polynomial;
pub mod secp256k1_base;
pub mod secp256k1_scalar;
#[cfg(test)]
mod field_testing;
#[cfg(test)]
mod prime_field_testing;

8
src/field/packable.rs → field/src/packable.rs
View File

@ -1,5 +1,5 @@
use crate::field::field_types::Field;
use crate::field::packed_field::PackedField;
use crate::field_types::Field;
use crate::packed_field::PackedField;
/// Points us to the default packing for a particular field. There may me multiple choices of
/// PackedField for a particular Field (e.g. every Field is also a PackedField), but this is the
@ -13,6 +13,6 @@ impl<F: Field> Packable for F {
}
#[cfg(all(target_arch = "x86_64", target_feature = "avx2"))]
impl Packable for crate::field::goldilocks_field::GoldilocksField {
type Packing = crate::field::arch::x86_64::avx2_goldilocks_field::Avx2GoldilocksField;
impl Packable for crate::goldilocks_field::GoldilocksField {
type Packing = crate::arch::x86_64::avx2_goldilocks_field::Avx2GoldilocksField;
}

2
src/field/packed_field.rs → field/src/packed_field.rs
View File

@ -3,7 +3,7 @@ use std::iter::{Product, Sum};
use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Sub, SubAssign};
use std::slice;
use crate::field::field_types::Field;
use crate::field_types::Field;
/// # Safety
/// - WIDTH is assumed to be a power of 2.

13
src/polynomial/division.rs → field/src/polynomial/division.rs
View File

@ -1,6 +1,7 @@
use crate::field::field_types::Field;
use plonky2_util::log2_ceil;
use crate::field_types::Field;
use crate::polynomial::PolynomialCoeffs;
use crate::util::log2_ceil;
impl<F: Field> PolynomialCoeffs<F> {
/// Polynomial division.
@ -68,7 +69,7 @@ impl<F: Field> PolynomialCoeffs<F> {
/// Let `self=p(X)`, this returns `(p(X)-p(z))/(X-z)` and `p(z)`.
/// See https://en.wikipedia.org/wiki/Horner%27s_method
pub(crate) fn divide_by_linear(&self, z: F) -> (PolynomialCoeffs<F>, F) {
pub fn divide_by_linear(&self, z: F) -> (PolynomialCoeffs<F>, F) {
let mut bs = self
.coeffs
.iter()
@ -126,9 +127,9 @@ impl<F: Field> PolynomialCoeffs<F> {
mod tests {
use std::time::Instant;
use crate::field::extension_field::quartic::QuarticExtension;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::extension_field::quartic::QuarticExtension;
use crate::field_types::Field;
use crate::goldilocks_field::GoldilocksField;
use crate::polynomial::PolynomialCoeffs;
#[test]

26
src/polynomial/mod.rs → field/src/polynomial/mod.rs
View File

@ -5,12 +5,12 @@ use std::iter::Sum;
use std::ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign};
use anyhow::{ensure, Result};
use plonky2_util::log2_strict;
use serde::{Deserialize, Serialize};
use crate::field::extension_field::{Extendable, FieldExtension};
use crate::field::fft::{fft, fft_with_options, ifft, FftRootTable};
use crate::field::field_types::Field;
use crate::util::log2_strict;
use crate::extension_field::{Extendable, FieldExtension};
use crate::fft::{fft, fft_with_options, ifft, FftRootTable};
use crate::field_types::Field;
/// A polynomial in point-value form.
///
@ -78,7 +78,7 @@ impl<F: Field> From<Vec<F>> for PolynomialValues<F> {
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(bound = "")]
pub struct PolynomialCoeffs<F: Field> {
pub(crate) coeffs: Vec<F>,
pub coeffs: Vec<F>,
}
impl<F: Field> PolynomialCoeffs<F> {
@ -86,15 +86,15 @@ impl<F: Field> PolynomialCoeffs<F> {
PolynomialCoeffs { coeffs }
}
pub(crate) fn empty() -> Self {
pub fn empty() -> Self {
Self::new(Vec::new())
}
pub(crate) fn zero(len: usize) -> Self {
pub fn zero(len: usize) -> Self {
Self::new(vec![F::ZERO; len])
}
pub(crate) fn is_zero(&self) -> bool {
pub fn is_zero(&self) -> bool {
self.coeffs.iter().all(|x| x.is_zero())
}
@ -108,7 +108,7 @@ impl<F: Field> PolynomialCoeffs<F> {
log2_strict(self.len())
}
pub(crate) fn chunks(&self, chunk_size: usize) -> Vec<Self> {
pub fn chunks(&self, chunk_size: usize) -> Vec<Self> {
self.coeffs
.chunks(chunk_size)
.map(|chunk| PolynomialCoeffs::new(chunk.to_vec()))
@ -163,7 +163,7 @@ impl<F: Field> PolynomialCoeffs<F> {
self.padded(self.len() << rate_bits)
}
pub(crate) fn pad(&mut self, new_len: usize) -> Result<()> {
pub fn pad(&mut self, new_len: usize) -> Result<()> {
ensure!(
new_len >= self.len(),
"Trying to pad a polynomial of length {} to a length of {}.",
@ -174,7 +174,7 @@ impl<F: Field> PolynomialCoeffs<F> {
Ok(())
}
pub(crate) fn padded(&self, new_len: usize) -> Self {
pub fn padded(&self, new_len: usize) -> Self {
let mut poly = self.clone();
poly.pad(new_len).unwrap();
poly
@ -192,7 +192,7 @@ impl<F: Field> PolynomialCoeffs<F> {
}
/// Degree of the polynomial + 1, or 0 for a polynomial with no non-zero coefficients.
pub(crate) fn degree_plus_one(&self) -> usize {
pub fn degree_plus_one(&self) -> usize {
(0usize..self.len())
.rev()
.find(|&i| self.coeffs[i].is_nonzero())
@ -397,7 +397,7 @@ mod tests {
use rand::{thread_rng, Rng};
use super::*;
use crate::field::goldilocks_field::GoldilocksField;
use crate::goldilocks_field::GoldilocksField;
#[test]
fn test_trimmed() {

16
src/field/prime_field_testing.rs → field/src/prime_field_testing.rs
View File

@ -1,4 +1,4 @@
use crate::field::field_types::PrimeField;
use crate::field_types::PrimeField;
/// Generates a series of non-negative integers less than `modulus` which cover a range of
/// interesting test values.
@ -70,12 +70,12 @@ macro_rules! test_prime_field_arithmetic {
mod prime_field_arithmetic {
use std::ops::{Add, Mul, Neg, Sub};
use crate::field::field_types::{Field, PrimeField};
use crate::field_types::{Field, PrimeField};
#[test]
fn arithmetic_addition() {
let modulus = <$field>::ORDER;
crate::field::prime_field_testing::run_binaryop_test_cases(<$field>::add, |x, y| {
crate::prime_field_testing::run_binaryop_test_cases(<$field>::add, |x, y| {
((x as u128 + y as u128) % (modulus as u128)) as u64
})
}
@ -83,7 +83,7 @@ macro_rules! test_prime_field_arithmetic {
#[test]
fn arithmetic_subtraction() {
let modulus = <$field>::ORDER;
crate::field::prime_field_testing::run_binaryop_test_cases(<$field>::sub, |x, y| {
crate::prime_field_testing::run_binaryop_test_cases(<$field>::sub, |x, y| {
if x >= y {
x - y
} else {
@ -95,7 +95,7 @@ macro_rules! test_prime_field_arithmetic {
#[test]
fn arithmetic_negation() {
let modulus = <$field>::ORDER;
crate::field::prime_field_testing::run_unaryop_test_cases(<$field>::neg, |x| {
crate::prime_field_testing::run_unaryop_test_cases(<$field>::neg, |x| {
if x == 0 {
0
} else {
@ -107,7 +107,7 @@ macro_rules! test_prime_field_arithmetic {
#[test]
fn arithmetic_multiplication() {
let modulus = <$field>::ORDER;
crate::field::prime_field_testing::run_binaryop_test_cases(<$field>::mul, |x, y| {
crate::prime_field_testing::run_binaryop_test_cases(<$field>::mul, |x, y| {
((x as u128) * (y as u128) % (modulus as u128)) as u64
})
}
@ -115,7 +115,7 @@ macro_rules! test_prime_field_arithmetic {
#[test]
fn arithmetic_square() {
let modulus = <$field>::ORDER;
crate::field::prime_field_testing::run_unaryop_test_cases(
crate::prime_field_testing::run_unaryop_test_cases(
|x: $field| x.square(),
|x| ((x as u128 * x as u128) % (modulus as u128)) as u64,
)
@ -129,7 +129,7 @@ macro_rules! test_prime_field_arithmetic {
assert_eq!(zero.try_inverse(), None);
let inputs = crate::field::prime_field_testing::test_inputs(modulus);
let inputs = crate::prime_field_testing::test_inputs(modulus);
for x in inputs {
if x != 0 {

4
src/field/secp256k1_base.rs → field/src/secp256k1_base.rs
View File

@ -10,7 +10,7 @@ use num::{Integer, One};
use rand::Rng;
use serde::{Deserialize, Serialize};
use crate::field::field_types::Field;
use crate::field_types::Field;
/// The base field of the secp256k1 elliptic curve.
///
@ -244,5 +244,5 @@ impl DivAssign for Secp256K1Base {
mod tests {
use crate::test_field_arithmetic;
test_field_arithmetic!(crate::field::secp256k1_base::Secp256K1Base);
test_field_arithmetic!(crate::secp256k1_base::Secp256K1Base);
}

4
src/field/secp256k1_scalar.rs → field/src/secp256k1_scalar.rs
View File

@ -11,7 +11,7 @@ use num::{Integer, One};
use rand::Rng;
use serde::{Deserialize, Serialize};
use crate::field::field_types::Field;
use crate::field_types::Field;
/// The base field of the secp256k1 elliptic curve.
///
@ -253,5 +253,5 @@ impl DivAssign for Secp256K1Scalar {
mod tests {
use crate::test_field_arithmetic;
test_field_arithmetic!(crate::field::secp256k1_scalar::Secp256K1Scalar);
test_field_arithmetic!(crate::secp256k1_scalar::Secp256K1Scalar);
}

9
insertion/Cargo.toml Normal file
View File

@ -0,0 +1,9 @@
[package]
name = "plonky2_insertion"
description = "Circuit implementation of list insertion"
version = "0.1.0"
edition = "2021"
[dependencies]
plonky2 = { path = "../plonky2" }
anyhow = "1.0.40"

39
src/gadgets/insert.rs → insertion/src/insert_gadget.rs
View File

@ -1,14 +1,26 @@
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use crate::gates::insertion::InsertionGate;
use crate::iop::target::Target;
use crate::plonk::circuit_builder::CircuitBuilder;
use plonky2::field::extension_field::Extendable;
use plonky2::hash::hash_types::RichField;
use plonky2::iop::ext_target::ExtensionTarget;
use plonky2::iop::target::Target;
use plonky2::plonk::circuit_builder::CircuitBuilder;
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
use crate::insertion_gate::InsertionGate;
pub trait CircuitBuilderInsert<F: RichField + Extendable<D>, const D: usize> {
/// Inserts a `Target` in a vector at a non-deterministic index.
/// Note: `index` is not range-checked.
pub fn insert(
fn insert(
&mut self,
index: Target,
element: ExtensionTarget<D>,
v: Vec<ExtensionTarget<D>>,
) -> Vec<ExtensionTarget<D>>;
}
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilderInsert<F, D>
for CircuitBuilder<F, D>
{
fn insert(
&mut self,
index: Target,
element: ExtensionTarget<D>,
@ -41,13 +53,12 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2::field::field_types::Field;
use plonky2::iop::witness::PartialWitness;
use plonky2::plonk::circuit_data::CircuitConfig;
use plonky2::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
use super::*;
use crate::field::field_types::Field;
use crate::iop::witness::PartialWitness;
use crate::plonk::circuit_data::CircuitConfig;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
use crate::plonk::verifier::verify;
fn real_insert<const D: usize>(
index: usize,
@ -88,7 +99,7 @@ mod tests {
let data = builder.build::<C>();
let proof = data.prove(pw)?;
verify(proof, &data.verifier_only, &data.common)
data.verify(proof)
}
#[test]

45
src/gates/insertion.rs → insertion/src/insertion_gate.rs
View File

@ -1,26 +1,27 @@
use std::marker::PhantomData;
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::{Extendable, FieldExtension};
use crate::field::field_types::{Field, RichField};
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase};
use plonky2::field::extension_field::{Extendable, FieldExtension};
use plonky2::field::field_types::Field;
use plonky2::gates::gate::Gate;
use plonky2::gates::util::StridedConstraintConsumer;
use plonky2::hash::hash_types::RichField;
use plonky2::iop::ext_target::ExtensionTarget;
use plonky2::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use plonky2::iop::target::Target;
use plonky2::iop::wire::Wire;
use plonky2::iop::witness::{PartitionWitness, Witness};
use plonky2::plonk::circuit_builder::CircuitBuilder;
use plonky2::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase};
/// A gate for inserting a value into a list at a non-deterministic location.
#[derive(Clone, Debug)]
pub(crate) struct InsertionGate<F: Extendable<D>, const D: usize> {
pub(crate) struct InsertionGate<F: RichField + Extendable<D>, const D: usize> {
pub vec_size: usize,
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> InsertionGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> InsertionGate<F, D> {
pub fn new(vec_size: usize) -> Self {
Self {
vec_size,
@ -70,7 +71,7 @@ impl<F: Extendable<D>, const D: usize> InsertionGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for InsertionGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for InsertionGate<F, D> {
fn id(&self) -> String {
format!("{:?}<D={}>", self, D)
}
@ -323,15 +324,15 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2::field::field_types::Field;
use plonky2::field::goldilocks_field::GoldilocksField;
use plonky2::gates::gate::Gate;
use plonky2::gates::gate_testing::{test_eval_fns, test_low_degree};
use plonky2::hash::hash_types::HashOut;
use plonky2::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
use plonky2::plonk::vars::EvaluationVars;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::insertion::InsertionGate;
use crate::hash::hash_types::HashOut;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
use crate::plonk::vars::EvaluationVars;
use crate::insertion_gate::InsertionGate;
#[test]
fn wire_indices() {

9
insertion/src/lib.rs Normal file
View File

@ -0,0 +1,9 @@
#![allow(clippy::new_without_default)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::type_complexity)]
#![allow(clippy::len_without_is_empty)]
#![allow(clippy::needless_range_loop)]
#![allow(clippy::return_self_not_must_use)]
pub mod insert_gadget;
pub mod insertion_gate;

61
plonky2/Cargo.toml Normal file
View File

@ -0,0 +1,61 @@
[package]
name = "plonky2"
description = "Recursive SNARKs based on Plonk and FRI"
version = "0.1.0"
authors = ["Daniel Lubarov <daniel@mirprotocol.org>"]
readme = "README.md"
license = "MIT OR Apache-2.0"
repository = "https://github.com/mir-protocol/plonky2"
keywords = ["cryptography", "SNARK", "FRI"]
categories = ["cryptography"]
edition = "2021"
default-run = "bench_recursion"
[dependencies]
plonky2_field = { path = "../field" }
plonky2_util = { path = "../util" }
array_tool = "1.0.3"
env_logger = "0.9.0"
log = "0.4.14"
itertools = "0.10.0"
num = { version = "0.4", features = [ "rand" ] }
rand = "0.8.4"
rand_chacha = "0.3.1"
rayon = "1.5.1"
unroll = "0.1.5"
anyhow = "1.0.40"
serde = { version = "1.0", features = ["derive"] }
serde_cbor = "0.11.1"
keccak-hash = "0.8.0"
static_assertions = "1.1.0"
[target.'cfg(not(target_env = "msvc"))'.dependencies]
jemallocator = "0.3.2"
[dev-dependencies]
criterion = "0.3.5"
tynm = "0.1.6"
[[bench]]
name = "field_arithmetic"
harness = false
[[bench]]
name = "ffts"
harness = false
[[bench]]
name = "hashing"
harness = false
[[bench]]
name = "transpose"
harness = false
[profile.release]
opt-level = 3
#lto = "fat"
#codegen-units = 1
[profile.bench]
opt-level = 3

2
benches/ffts.rs → plonky2/benches/ffts.rs
View File

@ -1,7 +1,7 @@
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use plonky2::field::field_types::Field;
use plonky2::field::goldilocks_field::GoldilocksField;
use plonky2::polynomial::PolynomialCoeffs;
use plonky2::field::polynomial::PolynomialCoeffs;
use tynm::type_name;
pub(crate) fn bench_ffts<F: Field>(c: &mut Criterion) {

0
benches/field_arithmetic.rs → plonky2/benches/field_arithmetic.rs
View File

0
benches/hashing.rs → plonky2/benches/hashing.rs
View File

0
benches/transpose.rs → plonky2/benches/transpose.rs
View File

6
src/bin/bench_ldes.rs → plonky2/src/bin/bench_ldes.rs
View File

@ -1,8 +1,8 @@
use std::time::Instant;
use plonky2::field::field_types::Field;
use plonky2::field::goldilocks_field::GoldilocksField;
use plonky2::polynomial::PolynomialValues;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use plonky2_field::polynomial::PolynomialValues;
use rayon::prelude::*;
type F = GoldilocksField;

0
src/bin/bench_recursion.rs → plonky2/src/bin/bench_recursion.rs
View File

4
src/bin/generate_constants.rs → plonky2/src/bin/generate_constants.rs
View File

@ -2,8 +2,8 @@
#![allow(clippy::needless_range_loop)]
use plonky2::field::field_types::PrimeField;
use plonky2::field::goldilocks_field::GoldilocksField;
use plonky2_field::field_types::PrimeField;
use plonky2_field::goldilocks_field::GoldilocksField;
use rand::{Rng, SeedableRng};
use rand_chacha::ChaCha8Rng;

3
src/curve/curve_adds.rs → plonky2/src/curve/curve_adds.rs
View File

@ -1,7 +1,8 @@
use std::ops::Add;
use plonky2_field::field_types::Field;
use crate::curve::curve_types::{AffinePoint, Curve, ProjectivePoint};
use crate::field::field_types::Field;
impl<C: Curve> Add<ProjectivePoint<C>> for ProjectivePoint<C> {
type Output = ProjectivePoint<C>;

6
src/curve/curve_msm.rs → plonky2/src/curve/curve_msm.rs
View File

@ -1,9 +1,9 @@
use itertools::Itertools;
use plonky2_field::field_types::Field;
use rayon::prelude::*;
use crate::curve::curve_summation::affine_multisummation_best;
use crate::curve::curve_types::{AffinePoint, Curve, ProjectivePoint};
use crate::field::field_types::Field;
/// In Yao's method, we compute an affine summation for each digit. In a parallel setting, it would
/// be easiest to assign individual summations to threads, but this would be sub-optimal because
@ -186,12 +186,12 @@ pub(crate) fn to_digits<C: Curve>(x: &C::ScalarField, w: usize) -> Vec<usize> {
#[cfg(test)]
mod tests {
use num::BigUint;
use plonky2_field::field_types::Field;
use plonky2_field::secp256k1_scalar::Secp256K1Scalar;
use crate::curve::curve_msm::{msm_execute, msm_precompute, to_digits};
use crate::curve::curve_types::Curve;
use crate::curve::secp256k1::Secp256K1;
use crate::field::field_types::Field;
use crate::field::secp256k1_scalar::Secp256K1Scalar;
#[test]
fn test_to_digits() {

3
src/curve/curve_multiplication.rs → plonky2/src/curve/curve_multiplication.rs
View File

@ -1,7 +1,8 @@
use std::ops::Mul;
use plonky2_field::field_types::Field;
use crate::curve::curve_types::{Curve, CurveScalar, ProjectivePoint};
use crate::field::field_types::Field;
const WINDOW_BITS: usize = 4;
const BASE: usize = 1 << WINDOW_BITS;

3
src/curve/curve_summation.rs → plonky2/src/curve/curve_summation.rs
View File

@ -1,7 +1,8 @@
use std::iter::Sum;
use plonky2_field::field_types::Field;
use crate::curve::curve_types::{AffinePoint, Curve, ProjectivePoint};
use crate::field::field_types::Field;
impl<C: Curve> Sum<AffinePoint<C>> for ProjectivePoint<C> {
fn sum<I: Iterator<Item = AffinePoint<C>>>(iter: I) -> ProjectivePoint<C> {

2
src/curve/curve_types.rs → plonky2/src/curve/curve_types.rs
View File

@ -1,7 +1,7 @@
use std::fmt::Debug;
use std::ops::Neg;
use crate::field::field_types::Field;
use plonky2_field::field_types::Field;
// To avoid implementation conflicts from associated types,
// see https://github.com/rust-lang/rust/issues/20400

0
src/curve/mod.rs → plonky2/src/curve/mod.rs
View File

11
src/curve/secp256k1.rs → plonky2/src/curve/secp256k1.rs
View File

@ -1,7 +1,8 @@
use plonky2_field::field_types::Field;
use plonky2_field::secp256k1_base::Secp256K1Base;
use plonky2_field::secp256k1_scalar::Secp256K1Scalar;
use crate::curve::curve_types::{AffinePoint, Curve};
use crate::field::field_types::Field;
use crate::field::secp256k1_base::Secp256K1Base;
use crate::field::secp256k1_scalar::Secp256K1Scalar;
#[derive(Debug, Copy, Clone)]
pub struct Secp256K1;
@ -38,11 +39,11 @@ const SECP256K1_GENERATOR_Y: Secp256K1Base = Secp256K1Base([
#[cfg(test)]
mod tests {
use num::BigUint;
use plonky2_field::field_types::Field;
use plonky2_field::secp256k1_scalar::Secp256K1Scalar;
use crate::curve::curve_types::{AffinePoint, Curve, ProjectivePoint};
use crate::curve::secp256k1::Secp256K1;
use crate::field::field_types::Field;
use crate::field::secp256k1_scalar::Secp256K1Scalar;
#[test]
fn test_generator() {

21
src/fri/commitment.rs → plonky2/src/fri/commitment.rs
View File

@ -1,27 +1,34 @@
use plonky2_field::extension_field::Extendable;
use plonky2_field::fft::FftRootTable;
use plonky2_field::field_types::Field;
use plonky2_field::polynomial::{PolynomialCoeffs, PolynomialValues};
use plonky2_util::{log2_strict, reverse_index_bits_in_place};
use rayon::prelude::*;
use crate::field::extension_field::Extendable;
use crate::field::fft::FftRootTable;
use crate::field::field_types::Field;
use crate::fri::proof::FriProof;
use crate::fri::prover::fri_proof;
use crate::hash::hash_types::RichField;
use crate::hash::merkle_tree::MerkleTree;
use crate::iop::challenger::Challenger;
use crate::plonk::circuit_data::CommonCircuitData;
use crate::plonk::config::GenericConfig;
use crate::plonk::plonk_common::PlonkPolynomials;
use crate::plonk::proof::OpeningSet;
use crate::polynomial::{PolynomialCoeffs, PolynomialValues};
use crate::timed;
use crate::util::reducing::ReducingFactor;
use crate::util::reverse_bits;
use crate::util::timing::TimingTree;
use crate::util::{log2_strict, reverse_bits, reverse_index_bits_in_place, transpose};
use crate::util::transpose;
/// Four (~64 bit) field elements gives ~128 bit security.
pub const SALT_SIZE: usize = 4;
/// Represents a batch FRI based commitment to a list of polynomials.
pub struct PolynomialBatchCommitment<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> {
pub struct PolynomialBatchCommitment<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
const D: usize,
> {
pub polynomials: Vec<PolynomialCoeffs<F>>,
pub merkle_tree: MerkleTree<F, C::Hasher>,
pub degree_log: usize,
@ -29,7 +36,7 @@ pub struct PolynomialBatchCommitment<F: Extendable<D>, C: GenericConfig<D, F = F
pub blinding: bool,
}
impl<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
PolynomialBatchCommitment<F, C, D>
{
/// Creates a list polynomial commitment for the polynomials interpolating the values in `values`.

0
src/fri/mod.rs → plonky2/src/fri/mod.rs
View File

22
src/fri/proof.rs → plonky2/src/fri/proof.rs
View File

@ -1,27 +1,27 @@
use std::collections::HashMap;
use itertools::izip;
use plonky2_field::extension_field::{flatten, unflatten, Extendable};
use plonky2_field::polynomial::PolynomialCoeffs;
use serde::{Deserialize, Serialize};
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::{flatten, unflatten, Extendable};
use crate::field::field_types::RichField;
use crate::gadgets::polynomial::PolynomialCoeffsExtTarget;
use crate::hash::hash_types::MerkleCapTarget;
use crate::hash::hash_types::RichField;
use crate::hash::merkle_proofs::{MerkleProof, MerkleProofTarget};
use crate::hash::merkle_tree::MerkleCap;
use crate::hash::path_compression::{compress_merkle_proofs, decompress_merkle_proofs};
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::target::Target;
use crate::plonk::circuit_data::CommonCircuitData;
use crate::plonk::config::{GenericConfig, Hasher};
use crate::plonk::plonk_common::PolynomialsIndexBlinding;
use crate::plonk::proof::{FriInferredElements, ProofChallenges};
use crate::polynomial::PolynomialCoeffs;
/// Evaluations and Merkle proof produced by the prover in a FRI query step.
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
#[serde(bound = "")]
pub struct FriQueryStep<F: Extendable<D>, H: Hasher<F>, const D: usize> {
pub struct FriQueryStep<F: RichField + Extendable<D>, H: Hasher<F>, const D: usize> {
pub evals: Vec<F::Extension>,
pub merkle_proof: MerkleProof<F, H>,
}
@ -70,7 +70,7 @@ impl FriInitialTreeProofTarget {
/// Proof for a FRI query round.
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
#[serde(bound = "")]
pub struct FriQueryRound<F: Extendable<D>, H: Hasher<F>, const D: usize> {
pub struct FriQueryRound<F: RichField + Extendable<D>, H: Hasher<F>, const D: usize> {
pub initial_trees_proof: FriInitialTreeProof<F, H>,
pub steps: Vec<FriQueryStep<F, H, D>>,
}
@ -84,7 +84,7 @@ pub struct FriQueryRoundTarget<const D: usize> {
/// Compressed proof of the FRI query rounds.
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
#[serde(bound = "")]
pub struct CompressedFriQueryRounds<F: Extendable<D>, H: Hasher<F>, const D: usize> {
pub struct CompressedFriQueryRounds<F: RichField + Extendable<D>, H: Hasher<F>, const D: usize> {
/// Query indices.
pub indices: Vec<usize>,
/// Map from initial indices `i` to the `FriInitialProof` for the `i`th leaf.
@ -95,7 +95,7 @@ pub struct CompressedFriQueryRounds<F: Extendable<D>, H: Hasher<F>, const D: usi
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
#[serde(bound = "")]
pub struct FriProof<F: Extendable<D>, H: Hasher<F>, const D: usize> {
pub struct FriProof<F: RichField + Extendable<D>, H: Hasher<F>, const D: usize> {
/// A Merkle cap for each reduced polynomial in the commit phase.
pub commit_phase_merkle_caps: Vec<MerkleCap<F, H>>,
/// Query rounds proofs
@ -115,7 +115,7 @@ pub struct FriProofTarget<const D: usize> {
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
#[serde(bound = "")]
pub struct CompressedFriProof<F: Extendable<D>, H: Hasher<F>, const D: usize> {
pub struct CompressedFriProof<F: RichField + Extendable<D>, H: Hasher<F>, const D: usize> {
/// A Merkle cap for each reduced polynomial in the commit phase.
pub commit_phase_merkle_caps: Vec<MerkleCap<F, H>>,
/// Compressed query rounds proof.
@ -126,7 +126,7 @@ pub struct CompressedFriProof<F: Extendable<D>, H: Hasher<F>, const D: usize> {
pub pow_witness: F,
}
impl<F: Extendable<D>, H: Hasher<F>, const D: usize> FriProof<F, H, D> {
impl<F: RichField + Extendable<D>, H: Hasher<F>, const D: usize> FriProof<F, H, D> {
/// Compress all the Merkle paths in the FRI proof and remove duplicate indices.
pub fn compress<C: GenericConfig<D, F = F, Hasher = H>>(
self,
@ -232,7 +232,7 @@ impl<F: Extendable<D>, H: Hasher<F>, const D: usize> FriProof<F, H, D> {
}
}
impl<F: Extendable<D>, H: Hasher<F>, const D: usize> CompressedFriProof<F, H, D> {
impl<F: RichField + Extendable<D>, H: Hasher<F>, const D: usize> CompressedFriProof<F, H, D> {
/// Decompress all the Merkle paths in the FRI proof and reinsert duplicate indices.
pub(crate) fn decompress<C: GenericConfig<D, F = F, Hasher = H>>(
self,

26
src/fri/prover.rs → plonky2/src/fri/prover.rs
View File

@ -1,21 +1,21 @@
use plonky2_field::extension_field::{flatten, unflatten, Extendable};
use plonky2_field::polynomial::{PolynomialCoeffs, PolynomialValues};
use plonky2_util::reverse_index_bits_in_place;
use rayon::prelude::*;
use crate::field::extension_field::{flatten, unflatten, Extendable};
use crate::fri::proof::{FriInitialTreeProof, FriProof, FriQueryRound, FriQueryStep};
use crate::fri::FriConfig;
use crate::hash::hash_types::HashOut;
use crate::hash::hash_types::{HashOut, RichField};
use crate::hash::merkle_tree::MerkleTree;
use crate::iop::challenger::Challenger;
use crate::plonk::circuit_data::CommonCircuitData;
use crate::plonk::config::{GenericConfig, Hasher};
use crate::plonk::plonk_common::reduce_with_powers;
use crate::polynomial::{PolynomialCoeffs, PolynomialValues};
use crate::timed;
use crate::util::reverse_index_bits_in_place;
use crate::util::timing::TimingTree;
/// Builds a FRI proof.
pub fn fri_proof<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
pub fn fri_proof<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
initial_merkle_trees: &[&MerkleTree<F, C::Hasher>],
// Coefficients of the polynomial on which the LDT is performed. Only the first `1/rate` coefficients are non-zero.
lde_polynomial_coeffs: PolynomialCoeffs<F::Extension>,
@ -60,7 +60,7 @@ pub fn fri_proof<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
}
}
fn fri_committed_trees<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
fn fri_committed_trees<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
mut coeffs: PolynomialCoeffs<F::Extension>,
mut values: PolynomialValues<F::Extension>,
challenger: &mut Challenger<F, C::InnerHasher>,
@ -108,7 +108,7 @@ fn fri_committed_trees<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: us
(trees, coeffs)
}
fn fri_proof_of_work<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
fn fri_proof_of_work<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
current_hash: HashOut<F>,
config: &FriConfig,
) -> F {
@ -133,7 +133,11 @@ fn fri_proof_of_work<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usiz
.expect("Proof of work failed. This is highly unlikely!")
}
fn fri_prover_query_rounds<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
fn fri_prover_query_rounds<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
const D: usize,
>(
initial_merkle_trees: &[&MerkleTree<F, C::Hasher>],
trees: &[MerkleTree<F, C::Hasher>],
challenger: &mut Challenger<F, C::InnerHasher>,
@ -145,7 +149,11 @@ fn fri_prover_query_rounds<F: Extendable<D>, C: GenericConfig<D, F = F>, const D
.collect()
}
fn fri_prover_query_round<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
fn fri_prover_query_round<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
const D: usize,
>(
initial_merkle_trees: &[&MerkleTree<F, C::Hasher>],
trees: &[MerkleTree<F, C::Hasher>],
challenger: &mut Challenger<F, C::InnerHasher>,

12
src/fri/recursive_verifier.rs → plonky2/src/fri/recursive_verifier.rs
View File

@ -1,6 +1,7 @@
use crate::field::extension_field::target::{flatten_target, ExtensionTarget};
use crate::field::extension_field::Extendable;
use crate::field::field_types::{Field, RichField};
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use plonky2_util::{log2_strict, reverse_index_bits_in_place};
use crate::fri::proof::{FriInitialTreeProofTarget, FriProofTarget, FriQueryRoundTarget};
use crate::fri::FriConfig;
use crate::gadgets::interpolation::InterpolationGate;
@ -9,7 +10,9 @@ use crate::gates::interpolation::HighDegreeInterpolationGate;
use crate::gates::low_degree_interpolation::LowDegreeInterpolationGate;
use crate::gates::random_access::RandomAccessGate;
use crate::hash::hash_types::MerkleCapTarget;
use crate::hash::hash_types::RichField;
use crate::iop::challenger::RecursiveChallenger;
use crate::iop::ext_target::{flatten_target, ExtensionTarget};
use crate::iop::target::{BoolTarget, Target};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::{CircuitConfig, CommonCircuitData};
@ -17,10 +20,9 @@ use crate::plonk::config::{AlgebraicConfig, AlgebraicHasher, GenericConfig};
use crate::plonk::plonk_common::PlonkPolynomials;
use crate::plonk::proof::OpeningSetTarget;
use crate::util::reducing::ReducingFactorTarget;
use crate::util::{log2_strict, reverse_index_bits_in_place};
use crate::with_context;
impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// Computes P'(x^arity) from {P(x*g^i)}_(i=0..arity), where g is a `arity`-th root of unity
/// and P' is the FRI reduced polynomial.
fn compute_evaluation<C: GenericConfig<D, F = F>>(

0
src/fri/reduction_strategies.rs → plonky2/src/fri/reduction_strategies.rs
View File

26
src/fri/verifier.rs → plonky2/src/fri/verifier.rs
View File

@ -1,10 +1,12 @@
use anyhow::{ensure, Result};
use plonky2_field::extension_field::{flatten, Extendable, FieldExtension};
use plonky2_field::field_types::Field;
use plonky2_field::interpolation::{barycentric_weights, interpolate, interpolate2};
use plonky2_util::{log2_strict, reverse_index_bits_in_place};
use crate::field::extension_field::{flatten, Extendable, FieldExtension};
use crate::field::field_types::{Field, RichField};
use crate::field::interpolation::{barycentric_weights, interpolate, interpolate2};
use crate::fri::proof::{FriInitialTreeProof, FriProof, FriQueryRound};
use crate::fri::FriConfig;
use crate::hash::hash_types::RichField;
use crate::hash::merkle_proofs::verify_merkle_proof;
use crate::hash::merkle_tree::MerkleCap;
use crate::plonk::circuit_data::CommonCircuitData;
@ -12,7 +14,7 @@ use crate::plonk::config::{GenericConfig, Hasher};
use crate::plonk::plonk_common::PlonkPolynomials;
use crate::plonk::proof::{OpeningSet, ProofChallenges};
use crate::util::reducing::ReducingFactor;
use crate::util::{log2_strict, reverse_bits, reverse_index_bits_in_place};
use crate::util::reverse_bits;
/// Computes P'(x^arity) from {P(x*g^i)}_(i=0..arity), where g is a `arity`-th root of unity
/// and P' is the FRI reduced polynomial.
@ -123,13 +125,13 @@ fn fri_verify_initial_proof<F: RichField, H: Hasher<F>>(
/// Holds the reduced (by `alpha`) evaluations at `zeta` for the polynomial opened just at
/// zeta, for `Z` at zeta and for `Z` at `g*zeta`.
#[derive(Copy, Clone, Debug)]
pub(crate) struct PrecomputedReducedEvals<F: Extendable<D>, const D: usize> {
pub(crate) struct PrecomputedReducedEvals<F: RichField + Extendable<D>, const D: usize> {
pub single: F::Extension,
pub zs: F::Extension,
pub zs_right: F::Extension,
}
impl<F: Extendable<D>, const D: usize> PrecomputedReducedEvals<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> PrecomputedReducedEvals<F, D> {
pub(crate) fn from_os_and_alpha(os: &OpeningSet<F, D>, alpha: F::Extension) -> Self {
let mut alpha = ReducingFactor::new(alpha);
let single = alpha.reduce(
@ -151,7 +153,11 @@ impl<F: Extendable<D>, const D: usize> PrecomputedReducedEvals<F, D> {
}
}
pub(crate) fn fri_combine_initial<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
pub(crate) fn fri_combine_initial<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
const D: usize,
>(
proof: &FriInitialTreeProof<F, C::Hasher>,
alpha: F::Extension,
zeta: F::Extension,
@ -212,7 +218,11 @@ pub(crate) fn fri_combine_initial<F: Extendable<D>, C: GenericConfig<D, F = F>,
sum
}
fn fri_verifier_query_round<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
fn fri_verifier_query_round<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
const D: usize,
>(
challenges: &ProofChallenges<F, D>,
precomputed_reduced_evals: PrecomputedReducedEvals<F, D>,
initial_merkle_caps: &[MerkleCap<F, C::Hasher>],

8
src/gadgets/arithmetic.rs → plonky2/src/gadgets/arithmetic.rs
View File

@ -1,13 +1,15 @@
use std::borrow::Borrow;
use crate::field::extension_field::Extendable;
use crate::field::field_types::PrimeField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::PrimeField;
use crate::gates::arithmetic_base::ArithmeticGate;
use crate::gates::exponentiation::ExponentiationGate;
use crate::hash::hash_types::RichField;
use crate::iop::target::{BoolTarget, Target};
use crate::plonk::circuit_builder::CircuitBuilder;
impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// Computes `-x`.
pub fn neg(&mut self, x: Target) -> Target {
let neg_one = self.neg_one();

30
src/gadgets/arithmetic_extension.rs → plonky2/src/gadgets/arithmetic_extension.rs
View File

@ -1,16 +1,18 @@
use crate::field::extension_field::target::{ExtensionAlgebraTarget, ExtensionTarget};
use crate::field::extension_field::FieldExtension;
use crate::field::extension_field::{Extendable, OEF};
use crate::field::field_types::{Field, PrimeField};
use plonky2_field::extension_field::FieldExtension;
use plonky2_field::extension_field::{Extendable, OEF};
use plonky2_field::field_types::{Field, PrimeField};
use plonky2_util::bits_u64;
use crate::gates::arithmetic_extension::ArithmeticExtensionGate;
use crate::gates::multiplication_extension::MulExtensionGate;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::{ExtensionAlgebraTarget, ExtensionTarget};
use crate::iop::generator::{GeneratedValues, SimpleGenerator};
use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::util::bits_u64;
impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
pub fn arithmetic_extension(
&mut self,
const_0: F,
@ -484,7 +486,9 @@ struct QuotientGeneratorExtension<const D: usize> {
quotient: ExtensionTarget<D>,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for QuotientGeneratorExtension<D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
for QuotientGeneratorExtension<D>
{
fn dependencies(&self) -> Vec<Target> {
let mut deps = self.numerator.to_target_array().to_vec();
deps.extend(&self.denominator.to_target_array());
@ -507,7 +511,7 @@ pub struct PowersTarget<const D: usize> {
}
impl<const D: usize> PowersTarget<D> {
pub fn next<F: Extendable<D>>(
pub fn next<F: RichField + Extendable<D>>(
&mut self,
builder: &mut CircuitBuilder<F, D>,
) -> ExtensionTarget<D> {
@ -516,7 +520,7 @@ impl<const D: usize> PowersTarget<D> {
result
}
pub fn repeated_frobenius<F: Extendable<D>>(
pub fn repeated_frobenius<F: RichField + Extendable<D>>(
self,
k: usize,
builder: &mut CircuitBuilder<F, D>,
@ -529,7 +533,7 @@ impl<const D: usize> PowersTarget<D> {
}
}
impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
pub fn powers(&mut self, base: ExtensionTarget<D>) -> PowersTarget<D> {
PowersTarget {
base,
@ -551,10 +555,10 @@ pub(crate) struct ExtensionArithmeticOperation<F: PrimeField + Extendable<D>, co
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::extension_field::algebra::ExtensionAlgebra;
use plonky2_field::field_types::Field;
use crate::field::extension_field::algebra::ExtensionAlgebra;
use crate::field::extension_field::target::ExtensionAlgebraTarget;
use crate::field::field_types::Field;
use crate::iop::ext_target::ExtensionAlgebraTarget;
use crate::iop::witness::{PartialWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig;

5
src/gadgets/arithmetic_u32.rs → plonky2/src/gadgets/arithmetic_u32.rs
View File

@ -1,7 +1,8 @@
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use plonky2_field::extension_field::Extendable;
use crate::gates::arithmetic_u32::U32ArithmeticGate;
use crate::gates::subtraction_u32::U32SubtractionGate;
use crate::hash::hash_types::RichField;
use crate::iop::target::Target;
use crate::plonk::circuit_builder::CircuitBuilder;

4
src/gadgets/biguint.rs → plonky2/src/gadgets/biguint.rs
View File

@ -1,10 +1,10 @@
use std::marker::PhantomData;
use num::{BigUint, Integer};
use plonky2_field::extension_field::Extendable;
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use crate::gadgets::arithmetic_u32::U32Target;
use crate::hash::hash_types::RichField;
use crate::iop::generator::{GeneratedValues, SimpleGenerator};
use crate::iop::target::{BoolTarget, Target};
use crate::iop::witness::{PartitionWitness, Witness};

12
src/gadgets/curve.rs → plonky2/src/gadgets/curve.rs
View File

@ -1,7 +1,9 @@
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use crate::curve::curve_types::{AffinePoint, Curve, CurveScalar};
use crate::field::extension_field::Extendable;
use crate::field::field_types::{Field, RichField};
use crate::gadgets::nonnative::NonNativeTarget;
use crate::hash::hash_types::RichField;
use crate::plonk::circuit_builder::CircuitBuilder;
/// A Target representing an affine point on the curve `C`. We use incomplete arithmetic for efficiency,
@ -176,12 +178,12 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::secp256k1_base::Secp256K1Base;
use plonky2_field::secp256k1_scalar::Secp256K1Scalar;
use crate::curve::curve_types::{AffinePoint, Curve, CurveScalar};
use crate::curve::secp256k1::Secp256K1;
use crate::field::field_types::Field;
use crate::field::secp256k1_base::Secp256K1Base;
use crate::field::secp256k1_scalar::Secp256K1Scalar;
use crate::iop::witness::PartialWitness;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig;

5
src/gadgets/hash.rs → plonky2/src/gadgets/hash.rs
View File

@ -1,5 +1,6 @@
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use plonky2_field::extension_field::Extendable;
use crate::hash::hash_types::RichField;
use crate::hash::hashing::SPONGE_WIDTH;
use crate::iop::target::{BoolTarget, Target};
use crate::plonk::circuit_builder::CircuitBuilder;

15
src/gadgets/interpolation.rs → plonky2/src/gadgets/interpolation.rs
View File

@ -1,16 +1,17 @@
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use plonky2_field::extension_field::Extendable;
use crate::gates::gate::Gate;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::target::Target;
use crate::plonk::circuit_builder::CircuitBuilder;
/// Trait for gates which interpolate a polynomial, whose points are a (base field) coset of the multiplicative subgroup
/// with the given size, and whose values are extension field elements, given by input wires.
/// Outputs the evaluation of the interpolant at a given (extension field) evaluation point.
pub(crate) trait InterpolationGate<F: Extendable<D>, const D: usize>:
pub(crate) trait InterpolationGate<F: RichField + Extendable<D>, const D: usize>:
Gate<F, D> + Copy
{
fn new(subgroup_bits: usize) -> Self;
@ -107,10 +108,10 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::extension_field::FieldExtension;
use plonky2_field::field_types::Field;
use plonky2_field::interpolation::interpolant;
use crate::field::extension_field::FieldExtension;
use crate::field::field_types::Field;
use crate::field::interpolation::interpolant;
use crate::gates::interpolation::HighDegreeInterpolationGate;
use crate::gates::low_degree_interpolation::LowDegreeInterpolationGate;
use crate::iop::witness::PartialWitness;

3
src/gadgets/mod.rs → plonky2/src/gadgets/mod.rs
View File

@ -4,15 +4,12 @@ pub mod arithmetic_u32;
pub mod biguint;
pub mod curve;
pub mod hash;
pub mod insert;
pub mod interpolation;
pub mod multiple_comparison;
pub mod nonnative;
pub mod permutation;
pub mod polynomial;
pub mod random_access;
pub mod range_check;
pub mod select;
pub mod sorting;
pub mod split_base;
pub(crate) mod split_join;

9
src/gadgets/multiple_comparison.rs → plonky2/src/gadgets/multiple_comparison.rs
View File

@ -1,10 +1,11 @@
use plonky2_field::extension_field::Extendable;
use plonky2_util::ceil_div_usize;
use super::arithmetic_u32::U32Target;
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use crate::gates::comparison::ComparisonGate;
use crate::hash::hash_types::RichField;
use crate::iop::target::{BoolTarget, Target};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::util::ceil_div_usize;
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// Returns true if a is less than or equal to b, considered as base-`2^num_bits` limbs of a large value.
@ -69,9 +70,9 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
mod tests {
use anyhow::Result;
use num::BigUint;
use plonky2_field::field_types::Field;
use rand::Rng;
use crate::field::field_types::Field;
use crate::iop::witness::PartialWitness;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig;

10
src/gadgets/nonnative.rs → plonky2/src/gadgets/nonnative.rs
View File

@ -1,16 +1,16 @@
use std::marker::PhantomData;
use num::{BigUint, Zero};
use plonky2_field::{extension_field::Extendable, field_types::Field};
use plonky2_util::ceil_div_usize;
use crate::field::field_types::RichField;
use crate::field::{extension_field::Extendable, field_types::Field};
use crate::gadgets::arithmetic_u32::U32Target;
use crate::gadgets::biguint::BigUintTarget;
use crate::hash::hash_types::RichField;
use crate::iop::generator::{GeneratedValues, SimpleGenerator};
use crate::iop::target::{BoolTarget, Target};
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::util::ceil_div_usize;
#[derive(Clone, Debug)]
pub struct NonNativeTarget<FF: Field> {
@ -212,9 +212,9 @@ impl<F: RichField + Extendable<D>, const D: usize, FF: Field> SimpleGenerator<F>
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::secp256k1_base::Secp256K1Base;
use crate::field::field_types::Field;
use crate::field::secp256k1_base::Secp256K1Base;
use crate::iop::witness::PartialWitness;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig;

16
src/gadgets/polynomial.rs → plonky2/src/gadgets/polynomial.rs
View File

@ -1,5 +1,7 @@
use crate::field::extension_field::target::{ExtensionAlgebraTarget, ExtensionTarget};
use crate::field::extension_field::Extendable;
use plonky2_field::extension_field::Extendable;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::{ExtensionAlgebraTarget, ExtensionTarget};
use crate::iop::target::Target;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::util::reducing::ReducingFactorTarget;
@ -11,7 +13,7 @@ impl<const D: usize> PolynomialCoeffsExtTarget<D> {
self.0.len()
}
pub fn eval_scalar<F: Extendable<D>>(
pub fn eval_scalar<F: RichField + Extendable<D>>(
&self,
builder: &mut CircuitBuilder<F, D>,
point: Target,
@ -21,7 +23,7 @@ impl<const D: usize> PolynomialCoeffsExtTarget<D> {
point.reduce(&self.0, builder)
}
pub fn eval<F: Extendable<D>>(
pub fn eval<F: RichField + Extendable<D>>(
&self,
builder: &mut CircuitBuilder<F, D>,
point: ExtensionTarget<D>,
@ -40,7 +42,7 @@ impl<const D: usize> PolynomialCoeffsExtAlgebraTarget<D> {
point: ExtensionTarget<D>,
) -> ExtensionAlgebraTarget<D>
where
F: Extendable<D>,
F: RichField + Extendable<D>,
{
let mut acc = builder.zero_ext_algebra();
for &c in self.0.iter().rev() {
@ -55,7 +57,7 @@ impl<const D: usize> PolynomialCoeffsExtAlgebraTarget<D> {
point: ExtensionAlgebraTarget<D>,
) -> ExtensionAlgebraTarget<D>
where
F: Extendable<D>,
F: RichField + Extendable<D>,
{
let mut acc = builder.zero_ext_algebra();
for &c in self.0.iter().rev() {
@ -71,7 +73,7 @@ impl<const D: usize> PolynomialCoeffsExtAlgebraTarget<D> {
powers: &[ExtensionAlgebraTarget<D>],
) -> ExtensionAlgebraTarget<D>
where
F: Extendable<D>,
F: RichField + Extendable<D>,
{
debug_assert_eq!(self.0.len(), powers.len() + 1);
let acc = self.0[0];

12
src/gadgets/random_access.rs → plonky2/src/gadgets/random_access.rs
View File

@ -1,11 +1,13 @@
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use plonky2_field::extension_field::Extendable;
use plonky2_util::log2_strict;
use crate::gates::random_access::RandomAccessGate;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::target::Target;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::util::log2_strict;
impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// Checks that a `Target` matches a vector at a non-deterministic index.
/// Note: `access_index` is not range-checked.
pub fn random_access(&mut self, access_index: Target, claimed_element: Target, v: Vec<Target>) {
@ -55,9 +57,9 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::field_types::Field;
use super::*;
use crate::field::field_types::Field;
use crate::iop::witness::PartialWitness;
use crate::plonk::circuit_data::CircuitConfig;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};

7
src/gadgets/range_check.rs → plonky2/src/gadgets/range_check.rs
View File

@ -1,11 +1,12 @@
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use plonky2_field::extension_field::Extendable;
use crate::hash::hash_types::RichField;
use crate::iop::generator::{GeneratedValues, SimpleGenerator};
use crate::iop::target::{BoolTarget, Target};
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// Checks that `x < 2^n_log` using a `BaseSumGate`.
pub fn range_check(&mut self, x: Target, n_log: usize) {
self.split_le(x, n_log);

10
src/gadgets/select.rs → plonky2/src/gadgets/select.rs
View File

@ -1,9 +1,11 @@
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use plonky2_field::extension_field::Extendable;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::target::{BoolTarget, Target};
use crate::plonk::circuit_builder::CircuitBuilder;
impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// Selects `x` or `y` based on `b`, i.e., this returns `if b { x } else { y }`.
pub fn select_ext(
&mut self,
@ -39,8 +41,8 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::field_types::Field;
use crate::field::field_types::Field;
use crate::iop::witness::{PartialWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig;

9
src/gadgets/split_base.rs → plonky2/src/gadgets/split_base.rs
View File

@ -1,16 +1,17 @@
use std::borrow::Borrow;
use itertools::Itertools;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use crate::field::extension_field::Extendable;
use crate::field::field_types::Field;
use crate::gates::base_sum::BaseSumGate;
use crate::hash::hash_types::RichField;
use crate::iop::generator::{GeneratedValues, SimpleGenerator};
use crate::iop::target::{BoolTarget, Target};
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// Split the given element into a list of targets, where each one represents a
/// base-B limb of the element, with little-endian ordering.
pub fn split_le_base<const B: usize>(&mut self, x: Target, num_limbs: usize) -> Vec<Target> {
@ -104,9 +105,9 @@ impl<F: Field, const B: usize> SimpleGenerator<F> for BaseSumGenerator<B> {
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::field_types::Field;
use rand::{thread_rng, Rng};
use crate::field::field_types::Field;
use crate::iop::witness::PartialWitness;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig;

7
src/gadgets/split_join.rs → plonky2/src/gadgets/split_join.rs
View File

@ -1,11 +1,12 @@
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use plonky2_field::extension_field::Extendable;
use plonky2_util::ceil_div_usize;
use crate::gates::base_sum::BaseSumGate;
use crate::hash::hash_types::RichField;
use crate::iop::generator::{GeneratedValues, SimpleGenerator};
use crate::iop::target::{BoolTarget, Target};
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::util::ceil_div_usize;
impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
/// Split the given integer into a list of wires, where each one represents a

11
src/gates/arithmetic_base.rs → plonky2/src/gates/arithmetic_base.rs
View File

@ -1,10 +1,11 @@
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};
@ -213,8 +214,8 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::arithmetic_base::ArithmeticGate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::plonk::circuit_data::CircuitConfig;

18
src/gates/arithmetic_extension.rs → plonky2/src/gates/arithmetic_extension.rs
View File

@ -1,10 +1,12 @@
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::extension_field::FieldExtension;
use plonky2_field::extension_field::Extendable;
use plonky2_field::extension_field::FieldExtension;
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};
@ -47,7 +49,7 @@ impl<const D: usize> ArithmeticExtensionGate<D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for ArithmeticExtensionGate<D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ArithmeticExtensionGate<D> {
fn id(&self) -> String {
format!("{:?}", self)
}
@ -157,14 +159,16 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ArithmeticExtensionGate<D>
}
#[derive(Clone, Debug)]
struct ArithmeticExtensionGenerator<F: Extendable<D>, const D: usize> {
struct ArithmeticExtensionGenerator<F: RichField + Extendable<D>, const D: usize> {
gate_index: usize,
const_0: F,
const_1: F,
i: usize,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for ArithmeticExtensionGenerator<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
for ArithmeticExtensionGenerator<F, D>
{
fn dependencies(&self) -> Vec<Target> {
ArithmeticExtensionGate::<D>::wires_ith_multiplicand_0(self.i)
.chain(ArithmeticExtensionGate::<D>::wires_ith_multiplicand_1(
@ -204,8 +208,8 @@ impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for ArithmeticExtensio
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::arithmetic_extension::ArithmeticExtensionGate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::plonk::circuit_data::CircuitConfig;

29
src/gates/arithmetic_u32.rs → plonky2/src/gates/arithmetic_u32.rs
View File

@ -1,14 +1,15 @@
use std::marker::PhantomData;
use itertools::unfold;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use plonky2_field::packed_field::PackedField;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::Field;
use crate::field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -22,12 +23,12 @@ use crate::plonk::vars::{
/// A gate to perform a basic mul-add on 32-bit values (we assume they are range-checked beforehand).
#[derive(Copy, Clone, Debug)]
pub struct U32ArithmeticGate<F: Extendable<D>, const D: usize> {
pub struct U32ArithmeticGate<F: RichField + Extendable<D>, const D: usize> {
pub num_ops: usize,
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> U32ArithmeticGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> U32ArithmeticGate<F, D> {
pub fn new_from_config(config: &CircuitConfig) -> Self {
Self {
num_ops: Self::num_ops(config),
@ -77,7 +78,7 @@ impl<F: Extendable<D>, const D: usize> U32ArithmeticGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for U32ArithmeticGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for U32ArithmeticGate<F, D> {
fn id(&self) -> String {
format!("{:?}", self)
}
@ -231,7 +232,9 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for U32ArithmeticGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for U32ArithmeticGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> PackedEvaluableBase<F, D>
for U32ArithmeticGate<F, D>
{
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
vars: EvaluationVarsBasePacked<P>,
@ -277,14 +280,16 @@ impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for U32Arithmet
}
#[derive(Clone, Debug)]
struct U32ArithmeticGenerator<F: Extendable<D>, const D: usize> {
struct U32ArithmeticGenerator<F: RichField + Extendable<D>, const D: usize> {
gate: U32ArithmeticGate<F, D>,
gate_index: usize,
i: usize,
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for U32ArithmeticGenerator<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
for U32ArithmeticGenerator<F, D>
{
fn dependencies(&self) -> Vec<Target> {
let local_target = |input| Target::wire(self.gate_index, input);
@ -344,10 +349,10 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use rand::Rng;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::arithmetic_u32::U32ArithmeticGate;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};

18
src/gates/assert_le.rs → plonky2/src/gates/assert_le.rs
View File

@ -1,12 +1,15 @@
use std::marker::PhantomData;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::{Field, PrimeField, RichField};
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::{Field, PrimeField};
use plonky2_field::packed_field::PackedField;
use plonky2_util::{bits_u64, ceil_div_usize};
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -17,7 +20,6 @@ use crate::plonk::vars::{
EvaluationTargets, EvaluationVars, EvaluationVarsBase, EvaluationVarsBaseBatch,
EvaluationVarsBasePacked,
};
use crate::util::{bits_u64, ceil_div_usize};
// TODO: replace/merge this gate with `ComparisonGate`.
@ -453,11 +455,11 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2_field::extension_field::quartic::QuarticExtension;
use plonky2_field::field_types::{Field, PrimeField};
use plonky2_field::goldilocks_field::GoldilocksField;
use rand::Rng;
use crate::field::extension_field::quartic::QuarticExtension;
use crate::field::field_types::{Field, PrimeField};
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::assert_le::AssertLessThanGate;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};

16
src/gates/base_sum.rs → plonky2/src/gates/base_sum.rs
View File

@ -1,12 +1,14 @@
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::{Field, PrimeField, RichField};
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::{Field, PrimeField};
use plonky2_field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};
@ -43,7 +45,7 @@ impl<const B: usize> BaseSumGate<B> {
}
}
impl<F: Extendable<D>, const D: usize, const B: usize> Gate<F, D> for BaseSumGate<B> {
impl<F: RichField + Extendable<D>, const D: usize, const B: usize> Gate<F, D> for BaseSumGate<B> {
fn id(&self) -> String {
format!("{:?} + Base: {}", self, B)
}
@ -134,7 +136,7 @@ impl<F: Extendable<D>, const D: usize, const B: usize> Gate<F, D> for BaseSumGat
}
}
impl<F: Extendable<D>, const D: usize, const B: usize> PackedEvaluableBase<F, D>
impl<F: RichField + Extendable<D>, const D: usize, const B: usize> PackedEvaluableBase<F, D>
for BaseSumGate<B>
{
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
@ -197,8 +199,8 @@ impl<F: RichField, const B: usize> SimpleGenerator<F> for BaseSplitGenerator<B>
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::base_sum::BaseSumGate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};

30
src/gates/comparison.rs → plonky2/src/gates/comparison.rs
View File

@ -1,12 +1,15 @@
use std::marker::PhantomData;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::{Field, PrimeField};
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::{Field, PrimeField};
use plonky2_field::packed_field::PackedField;
use plonky2_util::{bits_u64, ceil_div_usize};
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -17,7 +20,6 @@ use crate::plonk::vars::{
EvaluationTargets, EvaluationVars, EvaluationVarsBase, EvaluationVarsBaseBatch,
EvaluationVarsBasePacked,
};
use crate::util::{bits_u64, ceil_div_usize};
/// A gate for checking that one value is less than or equal to another.
#[derive(Clone, Debug)]
@ -27,7 +29,7 @@ pub struct ComparisonGate<F: PrimeField + Extendable<D>, const D: usize> {
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> ComparisonGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> ComparisonGate<F, D> {
pub fn new(num_bits: usize, num_chunks: usize) -> Self {
debug_assert!(num_bits < bits_u64(F::ORDER));
Self {
@ -88,7 +90,7 @@ impl<F: Extendable<D>, const D: usize> ComparisonGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate<F, D> {
fn id(&self) -> String {
format!("{:?}<D={}>", self, D)
}
@ -312,7 +314,9 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for ComparisonGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> PackedEvaluableBase<F, D>
for ComparisonGate<F, D>
{
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
vars: EvaluationVarsBasePacked<P>,
@ -394,12 +398,14 @@ impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for ComparisonG
}
#[derive(Debug)]
struct ComparisonGenerator<F: Extendable<D>, const D: usize> {
struct ComparisonGenerator<F: RichField + Extendable<D>, const D: usize> {
gate_index: usize,
gate: ComparisonGate<F, D>,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for ComparisonGenerator<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
for ComparisonGenerator<F, D>
{
fn dependencies(&self) -> Vec<Target> {
let local_target = |input| Target::wire(self.gate_index, input);
@ -515,10 +521,10 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2_field::field_types::{Field, PrimeField};
use plonky2_field::goldilocks_field::GoldilocksField;
use rand::Rng;
use crate::field::field_types::{Field, PrimeField};
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::comparison::ComparisonGate;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};

16
src/gates/constant.rs → plonky2/src/gates/constant.rs
View File

@ -1,12 +1,14 @@
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::Field;
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use plonky2_field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -33,7 +35,7 @@ impl ConstantGate {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for ConstantGate {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ConstantGate {
fn id(&self) -> String {
format!("{:?}", self)
}
@ -100,7 +102,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ConstantGate {
}
}
impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for ConstantGate {
impl<F: RichField + Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for ConstantGate {
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
vars: EvaluationVarsBasePacked<P>,
@ -140,8 +142,8 @@ impl<F: Field> SimpleGenerator<F> for ConstantGenerator<F> {
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::constant::ConstantGate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::plonk::circuit_data::CircuitConfig;

32
src/gates/exponentiation.rs → plonky2/src/gates/exponentiation.rs
View File

@ -1,12 +1,14 @@
use std::marker::PhantomData;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::Field;
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use plonky2_field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -20,12 +22,12 @@ use crate::plonk::vars::{
/// A gate for raising a value to a power.
#[derive(Clone, Debug)]
pub(crate) struct ExponentiationGate<F: Extendable<D>, const D: usize> {
pub(crate) struct ExponentiationGate<F: RichField + Extendable<D>, const D: usize> {
pub num_power_bits: usize,
pub _phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> ExponentiationGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> ExponentiationGate<F, D> {
pub fn new(num_power_bits: usize) -> Self {
Self {
num_power_bits,
@ -65,7 +67,7 @@ impl<F: Extendable<D>, const D: usize> ExponentiationGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for ExponentiationGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ExponentiationGate<F, D> {
fn id(&self) -> String {
format!("{:?}<D={}>", self, D)
}
@ -187,7 +189,9 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ExponentiationGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for ExponentiationGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> PackedEvaluableBase<F, D>
for ExponentiationGate<F, D>
{
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
vars: EvaluationVarsBasePacked<P>,
@ -225,12 +229,14 @@ impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for Exponentiat
}
#[derive(Debug)]
struct ExponentiationGenerator<F: Extendable<D>, const D: usize> {
struct ExponentiationGenerator<F: RichField + Extendable<D>, const D: usize> {
gate_index: usize,
gate: ExponentiationGate<F, D>,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for ExponentiationGenerator<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
for ExponentiationGenerator<F, D>
{
fn dependencies(&self) -> Vec<Target> {
let local_target = |input| Target::wire(self.gate_index, input);
@ -282,10 +288,11 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use plonky2_util::log2_ceil;
use rand::Rng;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::exponentiation::ExponentiationGate;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
@ -293,7 +300,6 @@ mod tests {
use crate::plonk::circuit_data::CircuitConfig;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
use crate::plonk::vars::EvaluationVars;
use crate::util::log2_ceil;
const MAX_POWER_BITS: usize = 17;

16
src/gates/gate.rs → plonky2/src/gates/gate.rs
View File

@ -2,12 +2,14 @@ use std::fmt::{Debug, Error, Formatter};
use std::hash::{Hash, Hasher};
use std::sync::Arc;
use crate::field::batch_util::batch_multiply_inplace;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::{Extendable, FieldExtension};
use crate::field::field_types::{Field, RichField};
use plonky2_field::batch_util::batch_multiply_inplace;
use plonky2_field::extension_field::{Extendable, FieldExtension};
use plonky2_field::field_types::Field;
use crate::gates::gate_tree::Tree;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::WitnessGenerator;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::vars::{
@ -15,7 +17,7 @@ use crate::plonk::vars::{
};
/// A custom gate.
pub trait Gate<F: Extendable<D>, const D: usize>: 'static + Send + Sync {
pub trait Gate<F: RichField + Extendable<D>, const D: usize>: 'static + Send + Sync {
fn id(&self) -> String;
fn eval_unfiltered(&self, vars: EvaluationVars<F, D>) -> Vec<F::Extension>;
@ -141,9 +143,9 @@ pub trait Gate<F: Extendable<D>, const D: usize>: 'static + Send + Sync {
/// A wrapper around an `Rc<Gate>` which implements `PartialEq`, `Eq` and `Hash` based on gate IDs.
#[derive(Clone)]
pub struct GateRef<F: Extendable<D>, const D: usize>(pub(crate) Arc<dyn Gate<F, D>>);
pub struct GateRef<F: RichField + Extendable<D>, const D: usize>(pub(crate) Arc<dyn Gate<F, D>>);
impl<F: Extendable<D>, const D: usize> GateRef<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> GateRef<F, D> {
pub fn new<G: Gate<F, D>>(gate: G) -> GateRef<F, D> {
GateRef(Arc::new(gate))
}

18
src/gates/gate_testing.rs → plonky2/src/gates/gate_testing.rs
View File

@ -1,26 +1,26 @@
use anyhow::{ensure, Result};
use plonky2_field::extension_field::{Extendable, FieldExtension};
use plonky2_field::field_types::Field;
use plonky2_field::polynomial::{PolynomialCoeffs, PolynomialValues};
use plonky2_util::log2_ceil;
use crate::field::extension_field::{Extendable, FieldExtension};
use crate::field::field_types::{Field, RichField};
use crate::gates::gate::Gate;
use crate::hash::hash_types::HashOut;
use crate::hash::hash_types::RichField;
use crate::iop::witness::{PartialWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig;
use crate::plonk::config::GenericConfig;
use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBaseBatch};
use crate::plonk::verifier::verify;
use crate::polynomial::{PolynomialCoeffs, PolynomialValues};
use crate::util::{log2_ceil, transpose};
use crate::util::transpose;
const WITNESS_SIZE: usize = 1 << 5;
const WITNESS_DEGREE: usize = WITNESS_SIZE - 1;
/// Tests that the constraints imposed by the given gate are low-degree by applying them to random
/// low-degree witness polynomials.
pub(crate) fn test_low_degree<F: RichField + Extendable<D>, G: Gate<F, D>, const D: usize>(
gate: G,
) {
pub fn test_low_degree<F: RichField + Extendable<D>, G: Gate<F, D>, const D: usize>(gate: G) {
let rate_bits = log2_ceil(gate.degree() + 1);
let wire_ldes = random_low_degree_matrix::<F::Extension>(gate.num_wires(), rate_bits);
@ -85,8 +85,8 @@ fn random_low_degree_values<F: Field>(rate_bits: usize) -> Vec<F> {
.values
}
pub(crate) fn test_eval_fns<
F: Extendable<D>,
pub fn test_eval_fns<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
G: Gate<F, D>,
const D: usize,

4
src/gates/gate_tree.rs → plonky2/src/gates/gate_tree.rs
View File

@ -1,8 +1,8 @@
use log::debug;
use plonky2_field::extension_field::Extendable;
use crate::field::extension_field::Extendable;
use crate::field::field_types::RichField;
use crate::gates::gate::GateRef;
use crate::hash::hash_types::RichField;
/// A binary tree where leaves hold some type `T` and other nodes are empty.
#[derive(Debug, Clone)]

40
src/gates/gmimc.rs → plonky2/src/gates/gmimc.rs
View File

@ -1,14 +1,16 @@
use std::marker::PhantomData;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::Field;
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use plonky2_field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::gmimc;
use crate::hash::gmimc::GMiMC;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -25,11 +27,17 @@ use crate::plonk::vars::{
/// It has a flag which can be used to swap the first four inputs with the next four, for ordering
/// sibling digests.
#[derive(Debug)]
pub struct GMiMCGate<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> {
pub struct GMiMCGate<
F: RichField + Extendable<D> + GMiMC<WIDTH>,
const D: usize,
const WIDTH: usize,
> {
_phantom: PhantomData<F>,
}
impl<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> GMiMCGate<F, D, WIDTH> {
impl<F: RichField + Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize>
GMiMCGate<F, D, WIDTH>
{
pub fn new() -> Self {
GMiMCGate {
_phantom: PhantomData,
@ -61,7 +69,7 @@ impl<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> GMiMCG
}
}
impl<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> Gate<F, D>
impl<F: RichField + Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> Gate<F, D>
for GMiMCGate<F, D, WIDTH>
{
fn id(&self) -> String {
@ -208,8 +216,8 @@ impl<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> Gate<F
}
}
impl<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> PackedEvaluableBase<F, D>
for GMiMCGate<F, D, WIDTH>
impl<F: RichField + Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize>
PackedEvaluableBase<F, D> for GMiMCGate<F, D, WIDTH>
{
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
@ -258,13 +266,17 @@ impl<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> Packed
}
#[derive(Debug)]
struct GMiMCGenerator<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> {
struct GMiMCGenerator<
F: RichField + Extendable<D> + GMiMC<WIDTH>,
const D: usize,
const WIDTH: usize,
> {
gate_index: usize,
_phantom: PhantomData<F>,
}
impl<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> SimpleGenerator<F>
for GMiMCGenerator<F, D, WIDTH>
impl<F: RichField + Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize>
SimpleGenerator<F> for GMiMCGenerator<F, D, WIDTH>
{
fn dependencies(&self) -> Vec<Target> {
let mut dep_input_indices = Vec::with_capacity(WIDTH + 1);
@ -341,9 +353,9 @@ impl<F: Extendable<D> + GMiMC<WIDTH>, const D: usize, const WIDTH: usize> Simple
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::gmimc::GMiMCGate;
use crate::hash::gmimc::GMiMC;

34
src/gates/interpolation.rs → plonky2/src/gates/interpolation.rs
View File

@ -1,31 +1,33 @@
use std::marker::PhantomData;
use std::ops::Range;
use crate::field::extension_field::algebra::PolynomialCoeffsAlgebra;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::{Extendable, FieldExtension};
use crate::field::interpolation::interpolant;
use plonky2_field::extension_field::algebra::PolynomialCoeffsAlgebra;
use plonky2_field::extension_field::{Extendable, FieldExtension};
use plonky2_field::interpolation::interpolant;
use plonky2_field::polynomial::PolynomialCoeffs;
use crate::gadgets::interpolation::InterpolationGate;
use crate::gadgets::polynomial::PolynomialCoeffsExtAlgebraTarget;
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase};
use crate::polynomial::PolynomialCoeffs;
/// Interpolation gate with constraints of degree at most `1<<subgroup_bits`.
/// `eval_unfiltered_recursively` uses less gates than `LowDegreeInterpolationGate`.
#[derive(Copy, Clone, Debug)]
pub(crate) struct HighDegreeInterpolationGate<F: Extendable<D>, const D: usize> {
pub(crate) struct HighDegreeInterpolationGate<F: RichField + Extendable<D>, const D: usize> {
pub subgroup_bits: usize,
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> InterpolationGate<F, D>
impl<F: RichField + Extendable<D>, const D: usize> InterpolationGate<F, D>
for HighDegreeInterpolationGate<F, D>
{
fn new(subgroup_bits: usize) -> Self {
@ -40,7 +42,7 @@ impl<F: Extendable<D>, const D: usize> InterpolationGate<F, D>
}
}
impl<F: Extendable<D>, const D: usize> HighDegreeInterpolationGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> HighDegreeInterpolationGate<F, D> {
/// End of wire indices, exclusive.
fn end(&self) -> usize {
self.start_coeffs() + self.num_points() * D
@ -79,7 +81,9 @@ impl<F: Extendable<D>, const D: usize> HighDegreeInterpolationGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for HighDegreeInterpolationGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D>
for HighDegreeInterpolationGate<F, D>
{
fn id(&self) -> String {
format!("{:?}<D={}>", self, D)
}
@ -200,13 +204,15 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for HighDegreeInterpolationGat
}
#[derive(Debug)]
struct InterpolationGenerator<F: Extendable<D>, const D: usize> {
struct InterpolationGenerator<F: RichField + Extendable<D>, const D: usize> {
gate_index: usize,
gate: HighDegreeInterpolationGate<F, D>,
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for InterpolationGenerator<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
for InterpolationGenerator<F, D>
{
fn dependencies(&self) -> Vec<Target> {
let local_target = |input| {
Target::Wire(Wire {
@ -269,9 +275,10 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use plonky2_field::polynomial::PolynomialCoeffs;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gadgets::interpolation::InterpolationGate;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
@ -279,7 +286,6 @@ mod tests {
use crate::hash::hash_types::HashOut;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
use crate::plonk::vars::EvaluationVars;
use crate::polynomial::PolynomialCoeffs;
#[test]
fn wire_indices() {

22
src/gates/low_degree_interpolation.rs → plonky2/src/gates/low_degree_interpolation.rs
View File

@ -1,22 +1,24 @@
use std::marker::PhantomData;
use std::ops::Range;
use crate::field::extension_field::algebra::PolynomialCoeffsAlgebra;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::{Extendable, FieldExtension};
use crate::field::field_types::{Field, RichField};
use crate::field::interpolation::interpolant;
use plonky2_field::extension_field::algebra::PolynomialCoeffsAlgebra;
use plonky2_field::extension_field::{Extendable, FieldExtension};
use plonky2_field::field_types::Field;
use plonky2_field::interpolation::interpolant;
use plonky2_field::polynomial::PolynomialCoeffs;
use crate::gadgets::interpolation::InterpolationGate;
use crate::gadgets::polynomial::PolynomialCoeffsExtAlgebraTarget;
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase};
use crate::polynomial::PolynomialCoeffs;
/// Interpolation gate with constraints of degree 2.
/// `eval_unfiltered_recursively` uses more gates than `HighDegreeInterpolationGate`.
@ -384,10 +386,11 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::extension_field::quadratic::QuadraticExtension;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use plonky2_field::polynomial::PolynomialCoeffs;
use crate::field::extension_field::quadratic::QuadraticExtension;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gadgets::interpolation::InterpolationGate;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
@ -395,7 +398,6 @@ mod tests {
use crate::hash::hash_types::HashOut;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
use crate::plonk::vars::EvaluationVars;
use crate::polynomial::PolynomialCoeffs;
#[test]
fn low_degree() {

8
src/gates/mod.rs → plonky2/src/gates/mod.rs
View File

@ -12,7 +12,6 @@ pub mod exponentiation;
pub mod gate;
pub mod gate_tree;
pub mod gmimc;
pub mod insertion;
pub mod interpolation;
pub mod low_degree_interpolation;
pub mod multiplication_extension;
@ -26,7 +25,8 @@ pub mod reducing;
pub mod reducing_extension;
pub mod subtraction_u32;
pub mod switch;
mod util;
pub mod util;
#[cfg(test)]
mod gate_testing;
// Can't use #[cfg(test)] here because it needs to be visible to other crates.
// See https://github.com/rust-lang/cargo/issues/8379
pub mod gate_testing;

11
src/gates/multiplication_extension.rs → plonky2/src/gates/multiplication_extension.rs
View File

@ -1,11 +1,12 @@
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::extension_field::FieldExtension;
use crate::field::field_types::RichField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::extension_field::FieldExtension;
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};
@ -186,8 +187,8 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::multiplication_extension::MulExtensionGate;
use crate::plonk::circuit_data::CircuitConfig;

11
src/gates/noop.rs → plonky2/src/gates/noop.rs
View File

@ -1,6 +1,8 @@
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use plonky2_field::extension_field::Extendable;
use crate::gates::gate::Gate;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::WitnessGenerator;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBaseBatch};
@ -8,7 +10,7 @@ use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBaseBa
/// A gate which does nothing.
pub struct NoopGate;
impl<F: Extendable<D>, const D: usize> Gate<F, D> for NoopGate {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for NoopGate {
fn id(&self) -> String {
"NoopGate".into()
}
@ -56,7 +58,8 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for NoopGate {
#[cfg(test)]
mod tests {
use crate::field::goldilocks_field::GoldilocksField;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::noop::NoopGate;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};

10
src/gates/packed_util.rs → plonky2/src/gates/packed_util.rs
View File

@ -1,11 +1,13 @@
use crate::field::extension_field::Extendable;
use crate::field::packable::Packable;
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::packable::Packable;
use plonky2_field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::plonk::vars::{EvaluationVarsBaseBatch, EvaluationVarsBasePacked};
pub trait PackedEvaluableBase<F: Extendable<D>, const D: usize>: Gate<F, D> {
pub trait PackedEvaluableBase<F: RichField + Extendable<D>, const D: usize>: Gate<F, D> {
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
vars_base: EvaluationVarsBasePacked<P>,

18
src/gates/poseidon.rs → plonky2/src/gates/poseidon.rs
View File

@ -1,14 +1,16 @@
use std::marker::PhantomData;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::{Field, RichField};
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use crate::gates::gate::Gate;
use crate::gates::poseidon_mds::PoseidonMdsGate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::hash::hashing::SPONGE_WIDTH;
use crate::hash::poseidon;
use crate::hash::poseidon::Poseidon;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -22,11 +24,11 @@ use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase};
/// It has a flag which can be used to swap the first four inputs with the next four, for ordering
/// sibling digests.
#[derive(Debug)]
pub struct PoseidonGate<F: Extendable<D>, const D: usize> {
pub struct PoseidonGate<F: RichField + Extendable<D>, const D: usize> {
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> PoseidonGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> PoseidonGate<F, D> {
pub fn new() -> Self {
PoseidonGate {
_phantom: PhantomData,
@ -94,7 +96,7 @@ impl<F: Extendable<D>, const D: usize> PoseidonGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for PoseidonGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PoseidonGate<F, D> {
fn id(&self) -> String {
format!("{:?}<WIDTH={}>", self, SPONGE_WIDTH)
}
@ -508,9 +510,9 @@ impl<F: RichField + Extendable<D> + Poseidon, const D: usize> SimpleGenerator<F>
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::poseidon::PoseidonGate;
use crate::hash::hashing::SPONGE_WIDTH;

12
src/gates/poseidon_mds.rs → plonky2/src/gates/poseidon_mds.rs
View File

@ -1,15 +1,17 @@
use std::marker::PhantomData;
use std::ops::Range;
use crate::field::extension_field::algebra::ExtensionAlgebra;
use crate::field::extension_field::target::{ExtensionAlgebraTarget, ExtensionTarget};
use crate::field::extension_field::Extendable;
use crate::field::extension_field::FieldExtension;
use crate::field::field_types::{Field, RichField};
use plonky2_field::extension_field::algebra::ExtensionAlgebra;
use plonky2_field::extension_field::Extendable;
use plonky2_field::extension_field::FieldExtension;
use plonky2_field::field_types::Field;
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::hash::hashing::SPONGE_WIDTH;
use crate::hash::poseidon::Poseidon;
use crate::iop::ext_target::{ExtensionAlgebraTarget, ExtensionTarget};
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};

15
src/gates/public_input.rs → plonky2/src/gates/public_input.rs
View File

@ -1,11 +1,13 @@
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::WitnessGenerator;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::vars::{
@ -22,7 +24,7 @@ impl PublicInputGate {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for PublicInputGate {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PublicInputGate {
fn id(&self) -> String {
"PublicInputGate".into()
}
@ -85,7 +87,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for PublicInputGate {
}
}
impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for PublicInputGate {
impl<F: RichField + Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for PublicInputGate {
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
vars: EvaluationVarsBasePacked<P>,
@ -101,7 +103,8 @@ impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for PublicInput
#[cfg(test)]
mod tests {
use crate::field::goldilocks_field::GoldilocksField;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::public_input::PublicInputGate;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};

29
src/gates/random_access.rs → plonky2/src/gates/random_access.rs
View File

@ -1,14 +1,15 @@
use std::marker::PhantomData;
use itertools::Itertools;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use plonky2_field::packed_field::PackedField;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::Field;
use crate::field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -22,13 +23,13 @@ use crate::plonk::vars::{
/// A gate for checking that a particular element of a list matches a given value.
#[derive(Copy, Clone, Debug)]
pub(crate) struct RandomAccessGate<F: Extendable<D>, const D: usize> {
pub(crate) struct RandomAccessGate<F: RichField + Extendable<D>, const D: usize> {
pub bits: usize,
pub num_copies: usize,
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> RandomAccessGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> RandomAccessGate<F, D> {
fn new(num_copies: usize, bits: usize) -> Self {
Self {
bits,
@ -84,7 +85,7 @@ impl<F: Extendable<D>, const D: usize> RandomAccessGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for RandomAccessGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for RandomAccessGate<F, D> {
fn id(&self) -> String {
format!("{:?}<D={}>", self, D)
}
@ -229,7 +230,9 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for RandomAccessGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for RandomAccessGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> PackedEvaluableBase<F, D>
for RandomAccessGate<F, D>
{
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
vars: EvaluationVarsBasePacked<P>,
@ -271,13 +274,15 @@ impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for RandomAcces
}
#[derive(Debug)]
struct RandomAccessGenerator<F: Extendable<D>, const D: usize> {
struct RandomAccessGenerator<F: RichField + Extendable<D>, const D: usize> {
gate_index: usize,
gate: RandomAccessGate<F, D>,
copy: usize,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for RandomAccessGenerator<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
for RandomAccessGenerator<F, D>
{
fn dependencies(&self) -> Vec<Target> {
let local_target = |input| Target::wire(self.gate_index, input);
@ -326,10 +331,10 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use rand::{thread_rng, Rng};
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::random_access::RandomAccessGate;

13
src/gates/reducing.rs → plonky2/src/gates/reducing.rs
View File

@ -1,11 +1,12 @@
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::extension_field::FieldExtension;
use crate::field::field_types::RichField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::extension_field::FieldExtension;
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};
@ -171,7 +172,7 @@ struct ReducingGenerator<const D: usize> {
gate: ReducingGate<D>,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for ReducingGenerator<D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F> for ReducingGenerator<D> {
fn dependencies(&self) -> Vec<Target> {
ReducingGate::<D>::wires_alpha()
.chain(ReducingGate::<D>::wires_old_acc())
@ -214,8 +215,8 @@ impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for ReducingGenerator<
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::reducing::ReducingGate;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};

13
src/gates/reducing_extension.rs → plonky2/src/gates/reducing_extension.rs
View File

@ -1,11 +1,12 @@
use std::ops::Range;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::extension_field::FieldExtension;
use crate::field::field_types::RichField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::extension_field::FieldExtension;
use crate::gates::gate::Gate;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};
@ -171,7 +172,7 @@ struct ReducingGenerator<const D: usize> {
gate: ReducingExtensionGate<D>,
}
impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for ReducingGenerator<D> {
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F> for ReducingGenerator<D> {
fn dependencies(&self) -> Vec<Target> {
ReducingExtensionGate::<D>::wires_alpha()
.chain(ReducingExtensionGate::<D>::wires_old_acc())
@ -207,8 +208,8 @@ impl<F: Extendable<D>, const D: usize> SimpleGenerator<F> for ReducingGenerator<
#[cfg(test)]
mod tests {
use anyhow::Result;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::reducing_extension::ReducingExtensionGate;
use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};

16
src/gates/subtraction_u32.rs → plonky2/src/gates/subtraction_u32.rs
View File

@ -1,12 +1,14 @@
use std::marker::PhantomData;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::{Field, RichField};
use crate::field::packed_field::PackedField;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use plonky2_field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -335,11 +337,11 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2_field::extension_field::quartic::QuarticExtension;
use plonky2_field::field_types::{Field, PrimeField};
use plonky2_field::goldilocks_field::GoldilocksField;
use rand::Rng;
use crate::field::extension_field::quartic::QuarticExtension;
use crate::field::field_types::{Field, PrimeField};
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::subtraction_u32::U32SubtractionGate;

27
src/gates/switch.rs → plonky2/src/gates/switch.rs
View File

@ -1,14 +1,15 @@
use std::marker::PhantomData;
use array_tool::vec::Union;
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
use plonky2_field::packed_field::PackedField;
use crate::field::extension_field::target::ExtensionTarget;
use crate::field::extension_field::Extendable;
use crate::field::field_types::Field;
use crate::field::packed_field::PackedField;
use crate::gates::gate::Gate;
use crate::gates::packed_util::PackedEvaluableBase;
use crate::gates::util::StridedConstraintConsumer;
use crate::hash::hash_types::RichField;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::generator::{GeneratedValues, WitnessGenerator};
use crate::iop::target::Target;
use crate::iop::wire::Wire;
@ -22,13 +23,13 @@ use crate::plonk::vars::{
/// A gate for conditionally swapping input values based on a boolean.
#[derive(Clone, Debug)]
pub(crate) struct SwitchGate<F: Extendable<D>, const D: usize> {
pub struct SwitchGate<F: RichField + Extendable<D>, const D: usize> {
pub(crate) chunk_size: usize,
pub(crate) num_copies: usize,
_phantom: PhantomData<F>,
}
impl<F: Extendable<D>, const D: usize> SwitchGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> SwitchGate<F, D> {
pub fn new(num_copies: usize, chunk_size: usize) -> Self {
Self {
chunk_size,
@ -72,7 +73,7 @@ impl<F: Extendable<D>, const D: usize> SwitchGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> Gate<F, D> for SwitchGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for SwitchGate<F, D> {
fn id(&self) -> String {
format!("{:?}<D={}>", self, D)
}
@ -188,7 +189,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for SwitchGate<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for SwitchGate<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for SwitchGate<F, D> {
fn eval_unfiltered_base_packed<P: PackedField<Scalar = F>>(
&self,
vars: EvaluationVarsBasePacked<P>,
@ -214,13 +215,13 @@ impl<F: Extendable<D>, const D: usize> PackedEvaluableBase<F, D> for SwitchGate<
}
#[derive(Debug)]
struct SwitchGenerator<F: Extendable<D>, const D: usize> {
struct SwitchGenerator<F: RichField + Extendable<D>, const D: usize> {
gate_index: usize,
gate: SwitchGate<F, D>,
copy: usize,
}
impl<F: Extendable<D>, const D: usize> SwitchGenerator<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> SwitchGenerator<F, D> {
fn in_out_dependencies(&self) -> Vec<Target> {
let local_target = |input| Target::wire(self.gate_index, input);
@ -307,7 +308,7 @@ impl<F: Extendable<D>, const D: usize> SwitchGenerator<F, D> {
}
}
impl<F: Extendable<D>, const D: usize> WitnessGenerator<F> for SwitchGenerator<F, D> {
impl<F: RichField + Extendable<D>, const D: usize> WitnessGenerator<F> for SwitchGenerator<F, D> {
fn watch_list(&self) -> Vec<Target> {
self.in_out_dependencies()
.union(self.in_switch_dependencies())
@ -331,9 +332,9 @@ mod tests {
use std::marker::PhantomData;
use anyhow::Result;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::gates::gate::Gate;
use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
use crate::gates::switch::SwitchGate;

2
src/gates/util.rs → plonky2/src/gates/util.rs
View File

@ -1,6 +1,6 @@
use std::marker::PhantomData;
use crate::field::packed_field::PackedField;
use plonky2_field::packed_field::PackedField;
/// Writes constraints yielded by a gate to a buffer, with a given stride.
/// Permits us to abstract the underlying memory layout. In particular, we can make a matrix of

0
src/hash/arch/aarch64/mod.rs → plonky2/src/hash/arch/aarch64/mod.rs
View File

4
src/hash/arch/aarch64/poseidon_goldilocks_neon.rs → plonky2/src/hash/arch/aarch64/poseidon_goldilocks_neon.rs
View File

@ -3,11 +3,11 @@
use std::arch::aarch64::*;
use std::arch::asm;
use plonky2_field::field_types::PrimeField;
use plonky2_field::goldilocks_field::GoldilocksField;
use static_assertions::const_assert;
use unroll::unroll_for_loops;
use crate::field::field_types::PrimeField;
use crate::field::goldilocks_field::GoldilocksField;
use crate::hash::poseidon::{
Poseidon, ALL_ROUND_CONSTANTS, HALF_N_FULL_ROUNDS, N_PARTIAL_ROUNDS, N_ROUNDS,
};

0
src/hash/arch/aarch64/readme-asm.md → plonky2/src/hash/arch/aarch64/readme-asm.md
View File

0
src/hash/arch/mod.rs → plonky2/src/hash/arch/mod.rs
View File

0
src/hash/arch/x86_64/mod.rs → plonky2/src/hash/arch/x86_64/mod.rs
View File

4
src/hash/arch/x86_64/poseidon_goldilocks_avx2_bmi2.rs → plonky2/src/hash/arch/x86_64/poseidon_goldilocks_avx2_bmi2.rs
View File

@ -2,10 +2,10 @@ use std::arch::asm;
use std::arch::x86_64::*;
use std::mem::size_of;
use plonky2_field::field_types::Field;
use plonky2_field::goldilocks_field::GoldilocksField;
use static_assertions::const_assert;
use crate::field::field_types::Field;
use crate::field::goldilocks_field::GoldilocksField;
use crate::hash::poseidon::{
Poseidon, ALL_ROUND_CONSTANTS, HALF_N_FULL_ROUNDS, N_PARTIAL_ROUNDS, N_ROUNDS,
};

Some files were not shown because too many files have changed in this diff Show More