Add data structures for multilinear extensions

CHANGELOG.md

@@ -4,6 +4,7 @@ The main features of this release are:
 
 - Adding the ability to define fields with integer parameters
 - Multi-variate polynomial support
+- Multilinear polynomial support
 - Many speedups to operations involving polynomials
 - Some speedups to `sqrt`
 - Small speedups to `MSM`s
@@ -26,6 +27,7 @@ The main features of this release are:
     by replacing `sparse_poly.evaluate(pt)` to `sparse_poly.evaluate(&pt)`.
 - #129 (ark-ff) Move `ark_ff::{UniformRand, test_rng}` to `ark_std::{UniformRand, test_rng}`.
     Importing these from `ark-ff` is still possible, but is deprecated and will be removed in the following release.
+- #140 (ark-poly) Rename `Evaluations` to `UVEvaluations` 
 - #144 (ark-poly) Add `CanonicalSerialize` and `CanonicalDeserialize` trait bounds for `Polynomial`.
 - #160 (ark-serialize, ark-ff, ark-ec) 
   - Remove `ConstantSerializedSize`; users should use `serialized_size*` (see next).
@@ -63,6 +65,7 @@ The main features of this release are:
 - #125 (ark-poly) Add parallelization to applying coset shifts within `coset_fft`.
 - #126 (ark-ec) Use `ark_ff::batch_inversion` for point normalization
 - #131, #137 (ark-ff) Speedup `sqrt` on fields when a square root exists. (And slows it down when doesn't exist)
+- #140 (ark-poly) Add support for multilinear extensions in dense and sparse evaluation form.
 - #141 (ark-ff) Add `Fp64`
 - #144 (ark-poly) Add serialization for polynomials and evaluations
 - #149 (ark-serialize) Add an impl of `CanonicalSerialize/Deserialize` for `String`.

README.md

@@ -19,7 +19,7 @@ This repository contains several Rust crates:
 
 * [`ark-ff`](ff): Provides generic implementations of various finite fields
 * [`ark-ec`](ec): Provides generic implementations for different kinds of elliptic curves, along with pairings over these
-* [`ark-poly`](poly): Implements polynomials and FFTs over finite fields
+* [`ark-poly`](poly): Implements polynomials (univariate, multivariate, and multilinear), and FFTs over finite fields. 
 * [`ark-serialize`](serialize): Provides efficient serialization and point compression for finite fields and elliptic curves
 
 In addition, the [`curves`](https://github.com/arkworks-rs/curves) repository contains implementations of popular elliptic curves; see [here](https://github.com/arkworks-rs/curves/README.md) for details.

poly-benches/Cargo.toml

@@ -27,8 +27,18 @@ path = "benches/fft.rs"
 harness = false
 
 [[bench]]
-name = "dense_polynomial"
-path = "benches/dense_polynomial.rs"
+name = "dense_uv_polynomial"
+path = "benches/dense_uv_polynomial.rs"
+harness = false
+
+[[bench]]
+name = "dense_multilinear"
+path = "benches/dense_multilinear.rs"
+harness = false
+
+[[bench]]
+name = "sparse_multilinear"
+path = "benches/sparse_multilinear.rs"
 harness = false
 
 [lib]

poly-benches/benches/dense_multilinear.rs

@@ -0,0 +1,56 @@
+#[macro_use]
+extern crate criterion;
+
+use ark_ff::Field;
+use ark_poly::{DenseMultilinearExtension, MultilinearExtension};
+use ark_std::ops::Range;
+use ark_std::test_rng;
+use ark_test_curves::bls12_381;
+use criterion::{black_box, BenchmarkId, Criterion};
+
+const NUM_VARIABLES_RANGE: Range<usize> = 10..21;
+
+fn arithmetic_op_bench<F: Field>(c: &mut Criterion) {
+    let mut rng = test_rng();
+
+    let mut group = c.benchmark_group("Add");
+    for nv in NUM_VARIABLES_RANGE {
+        group.bench_with_input(BenchmarkId::new("Add", nv), &nv, |b, &nv| {
+            let poly1 = DenseMultilinearExtension::<F>::rand(nv, nv, &mut rng);
+            let poly2 = DenseMultilinearExtension::<F>::rand(nv, nv, &mut rng);
+            b.iter(|| black_box(&poly1 + &poly2))
+        });
+    }
+    group.finish();
+
+    let mut group = c.benchmark_group("Sub");
+    for nv in NUM_VARIABLES_RANGE {
+        group.bench_with_input(BenchmarkId::new("Sub", nv), &nv, |b, &nv| {
+            let poly1 = DenseMultilinearExtension::<F>::rand(nv, nv, &mut rng);
+            let poly2 = DenseMultilinearExtension::<F>::rand(nv, nv, &mut rng);
+            b.iter(|| black_box(&poly1 - &poly2))
+        });
+    }
+    group.finish();
+}
+
+fn evaluation_op_bench<F: Field>(c: &mut Criterion) {
+    let mut rng = test_rng();
+    let mut group = c.benchmark_group("Evaluate");
+    for nv in NUM_VARIABLES_RANGE {
+        group.bench_with_input(BenchmarkId::new("evaluate", nv), &nv, |b, &nv| {
+            let poly = DenseMultilinearExtension::<F>::rand(nv, nv, &mut rng);
+            let point: Vec<_> = (0..nv).map(|_| F::rand(&mut rng)).collect();
+            b.iter(|| black_box(poly.evaluate(&point)))
+        });
+    }
+    group.finish();
+}
+
+fn bench_bls_381(c: &mut Criterion) {
+    arithmetic_op_bench::<bls12_381::Fr>(c);
+    evaluation_op_bench::<bls12_381::Fr>(c);
+}
+
+criterion_group!(benches, bench_bls_381);
+criterion_main!(benches);

poly-benches/benches/sparse_multilinear.rs

@@ -0,0 +1,91 @@
+#[macro_use]
+extern crate criterion;
+
+use ark_ff::Field;
+use ark_poly::{MultilinearExtension, SparseMultilinearExtension};
+use ark_std::ops::Range;
+use ark_std::test_rng;
+use ark_test_curves::bls12_381;
+use criterion::{black_box, BenchmarkId, Criterion};
+
+const NUM_VARIABLES_RANGE: Range<usize> = 12..23;
+
+fn arithmetic_op_bench<F: Field>(c: &mut Criterion) {
+    let mut rng = test_rng();
+
+    let mut group = c.benchmark_group("Add");
+    for nv in NUM_VARIABLES_RANGE {
+        let num_nonzero_entries = 1 << (nv / 2);
+        group.bench_with_input(
+            BenchmarkId::new("add", num_nonzero_entries),
+            &num_nonzero_entries,
+            |b, &num_nonzero_entries| {
+                let poly1 = SparseMultilinearExtension::<F>::rand_with_config(
+                    nv,
+                    num_nonzero_entries,
+                    &mut rng,
+                );
+                let poly2 = SparseMultilinearExtension::<F>::rand_with_config(
+                    nv,
+                    num_nonzero_entries,
+                    &mut rng,
+                );
+                b.iter(|| black_box(&poly1 + &poly2))
+            },
+        );
+    }
+    group.finish();
+
+    let mut group = c.benchmark_group("Sub");
+    for nv in NUM_VARIABLES_RANGE {
+        let num_nonzero_entries = 1 << (nv / 2);
+        group.bench_with_input(
+            BenchmarkId::new("sub", num_nonzero_entries),
+            &num_nonzero_entries,
+            |b, &num_nonzero_entries| {
+                let poly1 = SparseMultilinearExtension::<F>::rand_with_config(
+                    nv,
+                    num_nonzero_entries,
+                    &mut rng,
+                );
+                let poly2 = SparseMultilinearExtension::<F>::rand_with_config(
+                    nv,
+                    num_nonzero_entries,
+                    &mut rng,
+                );
+                b.iter(|| black_box(&poly1 - &poly2))
+            },
+        );
+    }
+    group.finish();
+}
+
+fn evaluation_op_bench<F: Field>(c: &mut Criterion) {
+    let mut rng = test_rng();
+    let mut group = c.benchmark_group("Evaluate");
+    for nv in NUM_VARIABLES_RANGE {
+        let num_nonzero_entries = 1 << (nv / 2);
+        group.bench_with_input(
+            BenchmarkId::new("evaluate", num_nonzero_entries),
+            &num_nonzero_entries,
+            |b, &num_nonzero_entries| {
+                let poly = SparseMultilinearExtension::<F>::rand_with_config(
+                    nv,
+                    num_nonzero_entries,
+                    &mut rng,
+                );
+                let point: Vec<_> = (0..nv).map(|_| F::rand(&mut rng)).collect();
+                b.iter(|| black_box(poly.evaluate(&point)))
+            },
+        );
+    }
+    group.finish();
+}
+
+fn bench_bls381(c: &mut Criterion) {
+    arithmetic_op_bench::<bls12_381::Fr>(c);
+    evaluation_op_bench::<bls12_381::Fr>(c);
+}
+
+criterion_group!(benches, bench_bls381);
+criterion_main!(benches);

poly/Cargo.toml

@@ -19,6 +19,7 @@ ark-std = { git = "https://github.com/arkworks-rs/utils", default-features = fal
 rand = { version = "0.7", default-features = false }
 rayon = { version = "1", optional = true }
 derivative = { version = "2", default-features = false, features = [ "use_core" ] }
+hashbrown = {version = "0.9.1"}
 
 [dev-dependencies]
 ark-test-curves = { path = "../test-curves", default-features = false, features = [ "bls12_381_curve", "mnt4_753_curve"] }

poly/README.md

@@ -4,7 +4,7 @@ This crate implements traits and implementations for polynomials, FFT-friendly s
 
 ### Polynomials
 
-The `polynomial` module provides the following traits for defining polynomials:
+The `polynomial` module provides the following traits for defining polynomials in coefficient form:
 
 - [`Polynomial`](https://github.com/arkworks-rs/algebra/blob/master/poly/src/polynomial/mod.rs#L16):
 Requires implementors to support common operations on polynomials,
@@ -30,6 +30,26 @@ Represents multivariate polynomials via a list containing all non-zero monomials
 
 This crate also provides the [`univariate/DenseOrSparsePolynomial`](https://github.com/arkworks-rs/algebra/blob/master/poly/src/polynomial/univariate/mod.rs#L16) enum, which allows the user to abstract over the type of underlying univariate polynomial (dense or sparse).
 
+### Evaluations
+
+The `evaluations` module provides data structures to represent univariate polynomials in lagrange form. 
+
+- [`univariate/UVEvaluations`](./src/evaluations/univariate/mod.rs#L18)
+Represents a univariate polynomial in evaluation form, which can be used for FFT.
+
+The `evaluations` module also provides the following traits for defining multivariate polynomials in lagrange form:
+
+- [`multivariate/multilinear/MultilinearExtension`](./src/evaluations/multivariate/multilinear/mod.rs#L20)
+Specifies a multilinear polynomial evaluated over boolean hypercube.
+
+This crate provides some data structures to implement these traits.
+
+- [`multivariate/multilinear/DenseMultilinearExtension`](./src/evaluations/multivariate/multilinear/dense.rs#L24)
+Represents multilinear extension via a list of evaluations over boolean hypercube.
+
+- [`multivariate/multilinear/SparseMultilinearExtension`](./src/evaluations/multivariate/multilinear/sparse.rs#L20)
+Represents multilinear extension via a list of non-zero evaluations over boolean hypercube.
+
 ### Domains
 
 TODO

poly/src/evaluations/mod.rs

@@ -0,0 +1,2 @@
+pub mod multivariate;
+pub mod univariate;

poly/src/evaluations/multivariate/mod.rs

@@ -0,0 +1,4 @@
+pub mod multilinear;
+pub use multilinear::{
+    DenseMultilinearExtension, MultilinearExtension, SparseMultilinearExtension,
+};