Sumcheck IOP for LogUp-GKR

Cargo.toml

@@ -11,7 +11,7 @@ members = [
   "verifier",
   "winterfell",
   "examples"
-]
+, "sumcheck"]
 resolver = "2"
 
 [profile.release]

air/src/air/logup_gkr.rs

@@ -0,0 +1,74 @@
+// Copyright (c) Facebook, Inc. and its affiliates.
+//
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+use alloc::vec::Vec;
+
+use super::EvaluationFrame;
+use math::{ExtensionOf, FieldElement, StarkField, ToElements};
+
+pub trait LogUpGkrEvaluator: Clone + Sync {
+    /// Defines the base field of the evaluator.
+    type BaseField: StarkField;
+
+    /// Public inputs need to compute the final claim.
+    type PublicInputs: ToElements<Self::BaseField> + Send;
+
+    /// Gets a list of all oracles involved in LogUp-GKR; this is intended to be used in construction of
+    /// MLEs.
+    fn get_oracles(&self) -> Vec<LogUpGkrOracle<Self::BaseField>>;
+
+    /// Returns the number of random values needed to evaluate a query.
+    fn get_num_rand_values(&self) -> usize;
+
+    /// Returns the number of fractions in the LogUp-GKR statement.
+    fn get_num_fractions(&self) -> usize;
+
+    /// Returns the maximal degree of the multi-variate associated to the input layer.
+    fn max_degree(&self) -> usize;
+
+    /// Builds a query from the provided main trace frame and periodic values.
+    ///
+    /// Note: it should be possible to provide an implementation of this method based on the
+    /// information returned from `get_oracles()`. However, this implementation is likely to be
+    /// expensive compared to the hand-written implementation. However, we could provide a test
+    /// which verifies that `get_oracles()` and `build_query()` methods are consistent.
+    fn build_query<E>(&self, frame: &EvaluationFrame<E>, periodic_values: &[E]) -> Vec<E>
+    where
+        E: FieldElement<BaseField = Self::BaseField>;
+
+    /// Evaluates the provided query and writes the results into the numerators and denominators.
+    ///
+    /// Note: it is also possible to combine `build_query()` and `evaluate_query()` into a single
+    /// method to avoid the need to first build the query struct and then evaluate it. However:
+    /// - We assume that the compiler will be able to optimize this away.
+    /// - Merging the methods will make it more difficult avoid inconsistencies between
+    ///   `evaluate_query()` and `get_oracles()` methods.
+    fn evaluate_query<F, E>(
+        &self,
+        query: &[F],
+        rand_values: &[E],
+        numerator: &mut [E],
+        denominator: &mut [E],
+    ) where
+        F: FieldElement<BaseField = Self::BaseField>,
+        E: FieldElement<BaseField = Self::BaseField> + ExtensionOf<F>;
+
+    /// Computes the final claim for the LogUp-GKR circuit.
+    ///
+    /// The default implementation of this method returns E::ZERO as it is expected that the
+    /// fractional sums will cancel out. However, in cases when some boundary conditions need to
+    /// be imposed on the LogUp-GKR relations, this method can be overridden to compute the final
+    /// expected claim.
+    fn compute_claim<E>(&self, inputs: &Self::PublicInputs, rand_values: &[E]) -> E
+    where
+        E: FieldElement<BaseField = Self::BaseField>;
+}
+
+#[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+pub enum LogUpGkrOracle<B: StarkField> {
+    CurrentRow(usize),
+    NextRow(usize),
+    PeriodicValue(Vec<B>),
+}

air/src/air/mod.rs

@@ -34,6 +34,9 @@ pub use lagrange::{
     LagrangeKernelRandElements, LagrangeKernelTransitionConstraints,
 };
 
+mod logup_gkr;
+pub use logup_gkr::{LogUpGkrEvaluator, LogUpGkrOracle};
+
 mod coefficients;
 pub use coefficients::{
     ConstraintCompositionCoefficients, DeepCompositionCoefficients,

air/src/lib.rs

@@ -47,6 +47,6 @@ pub use air::{
     DeepCompositionCoefficients, EvaluationFrame, GkrRandElements, GkrVerifier,
     LagrangeConstraintsCompositionCoefficients, LagrangeKernelBoundaryConstraint,
     LagrangeKernelConstraints, LagrangeKernelEvaluationFrame, LagrangeKernelRandElements,
-    LagrangeKernelTransitionConstraints, TraceInfo, TransitionConstraintDegree,
-    TransitionConstraints,
+    LagrangeKernelTransitionConstraints, LogUpGkrEvaluator, LogUpGkrOracle, TraceInfo,
+    TransitionConstraintDegree, TransitionConstraints,
 };

sumcheck/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "winter-sumcheck"
+version = "0.1.0"
+description = "Implementation of the sum-check protocol for the LogUp-GKR protocol"
+authors = ["winterfell contributors"]
+readme = "README.md"
+license = "MIT"
+repository = "https://github.com/novifinancial/winterfell"
+documentation = "https://docs.rs/winter-sumcheck/0.1.0"
+categories = ["cryptography", "no-std"]
+keywords = ["crypto", "sumcheck", "iop"]
+edition = "2021"
+rust-version = "1.78"
+
+[features]
+concurrent = ["utils/concurrent", "dep:rayon", "std"]
+default = ["std"]
+std = ["utils/std"]
+
+[dependencies]
+air = { version = "0.9", path = "../air", package = "winter-air", default-features = false }
+crypto = { version = "0.9", path = "../crypto", package = "winter-crypto", default-features = false }
+math = { version = "0.9", path = "../math", package = "winter-math", default-features = false }
+utils = { version = "0.9", path = "../utils/core", package = "winter-utils", default-features = false }
+rayon = { version = "1.8", optional = true }
+smallvec = { version = "1.13", default-features = false }
+thiserror = { version = "1.0", git = "https://github.com/bitwalker/thiserror", branch = "no-std", default-features = false }
+
+[dev-dependencies]
+criterion = "0.5"
+rand-utils = { version = "0.9", path = "../utils/rand", package = "winter-rand-utils" }