Add lookup mod and structs

src/plonk.rs

@@ -11,6 +11,7 @@ use crate::transcript::ChallengeScalar;
 
 mod circuit;
 mod keygen;
+mod lookup;
 mod permutation;
 mod prover;
 mod verifier;

src/plonk/lookup.rs

@@ -0,0 +1,33 @@
+use super::circuit::{Any, Column};
+use crate::arithmetic::CurveAffine;
+
+mod prover;
+mod verifier;
+
+#[derive(Clone, Debug)]
+pub(crate) struct Argument {
+    pub input_columns: Vec<Column<Any>>,
+    pub table_columns: Vec<Column<Any>>,
+}
+
+impl Argument {
+    pub fn new(input_columns: &[Column<Any>], table_columns: &[Column<Any>]) -> Self {
+        assert_eq!(input_columns.len(), table_columns.len());
+        Argument {
+            input_columns: input_columns.to_vec(),
+            table_columns: table_columns.to_vec(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Proof<C: CurveAffine> {
+    product_commitment: C,
+    product_eval: C::Scalar,
+    product_inv_eval: C::Scalar,
+    permuted_input_commitment: C,
+    permuted_table_commitment: C,
+    permuted_input_eval: C::Scalar,
+    permuted_input_inv_eval: C::Scalar,
+    permuted_table_eval: C::Scalar,
+}

src/plonk/lookup/prover.rs

@@ -0,0 +1,53 @@
+use crate::arithmetic::CurveAffine;
+use crate::poly::{commitment::Blind, Coeff, ExtendedLagrangeCoeff, LagrangeCoeff, Polynomial};
+
+#[derive(Clone, Debug)]
+pub(crate) struct Permuted<C: CurveAffine> {
+    permuted_input_value: Polynomial<C::Scalar, LagrangeCoeff>,
+    permuted_input_poly: Polynomial<C::Scalar, Coeff>,
+    permuted_input_coset: Polynomial<C::Scalar, ExtendedLagrangeCoeff>,
+    permuted_input_inv_coset: Polynomial<C::Scalar, ExtendedLagrangeCoeff>,
+    permuted_input_blind: Blind<C::Scalar>,
+    permuted_input_commitment: C,
+    permuted_table_value: Polynomial<C::Scalar, LagrangeCoeff>,
+    permuted_table_poly: Polynomial<C::Scalar, Coeff>,
+    permuted_table_coset: Polynomial<C::Scalar, ExtendedLagrangeCoeff>,
+    permuted_table_blind: Blind<C::Scalar>,
+    permuted_table_commitment: C,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Product<C: CurveAffine> {
+    product_poly: Polynomial<C::Scalar, Coeff>,
+    product_coset: Polynomial<C::Scalar, ExtendedLagrangeCoeff>,
+    product_inv_coset: Polynomial<C::Scalar, ExtendedLagrangeCoeff>,
+    product_blind: Blind<C::Scalar>,
+    product_commitment: C,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Committed<C: CurveAffine> {
+    permuted: Permuted<C>,
+    product: Product<C>,
+}
+
+pub(crate) struct Constructed<C: CurveAffine> {
+    permuted_input_poly: Polynomial<C::Scalar, Coeff>,
+    permuted_input_blind: Blind<C::Scalar>,
+    permuted_input_commitment: C,
+    permuted_table_poly: Polynomial<C::Scalar, Coeff>,
+    permuted_table_blind: Blind<C::Scalar>,
+    permuted_table_commitment: C,
+    product_poly: Polynomial<C::Scalar, Coeff>,
+    product_blind: Blind<C::Scalar>,
+    product_commitment: C,
+}
+
+pub(crate) struct Evaluated<C: CurveAffine> {
+    constructed: Constructed<C>,
+    pub product_eval: C::Scalar,
+    pub product_inv_eval: C::Scalar,
+    pub permuted_input_eval: C::Scalar,
+    pub permuted_input_inv_eval: C::Scalar,
+    pub permuted_table_eval: C::Scalar,
+}

src/plonk/lookup/verifier.rs

@@ -0,0 +1,4 @@
+use super::Proof;
+use crate::arithmetic::CurveAffine;
+
+impl<C: CurveAffine> Proof<C> {}