get operation_verify test working

Author: ed255

src/backends/plonky2/common.rs

@@ -1,8 +1,8 @@
 //! Common functionality to build Pod circuits with plonky2
 
-use crate::middleware::{
-    Operation, Params, Statement, StatementArg, ToFields, Value, F, HASH_SIZE, VALUE_SIZE,
-};
+use crate::backends::plonky2::mock_main::Statement;
+use crate::backends::plonky2::mock_main::{Operation, OperationArg};
+use crate::middleware::{Params, StatementArg, ToFields, Value, F, HASH_SIZE, VALUE_SIZE};
 use crate::middleware::{OPERATION_ARG_F_LEN, STATEMENT_ARG_F_LEN};
 use anyhow::Result;
 use plonky2::field::extension::Extendable;
@@ -68,7 +68,15 @@ impl OperationTarget {
         op: &Operation,
     ) -> Result<()> {
         pw.set_target_arr(&self.code, &op.code().to_fields(params))?;
-        // TODO: Arguments
+        for (i, arg) in op
+            .args()
+            .iter()
+            .chain(iter::repeat(&OperationArg::None))
+            .take(params.max_operation_args)
+            .enumerate()
+        {
+            pw.set_target_arr(&self.args[i], &arg.to_fields(params))?;
+        }
         Ok(())
     }
 }

src/backends/plonky2/main.rs

@@ -2,13 +2,14 @@ use crate::backends::plonky2::basetypes::{Hash, Value, D, EMPTY_HASH, EMPTY_VALU
 use crate::backends::plonky2::common::{
     CircuitBuilderPod, OperationTarget, StatementTarget, ValueTarget,
 };
+use crate::backends::plonky2::mock_main::Operation;
 use crate::backends::plonky2::primitives::merkletree::{MerkleProof, MerkleTree};
 use crate::backends::plonky2::primitives::merkletree::{
     MerkleProofExistenceGate, MerkleProofExistenceTarget,
 };
 use crate::middleware::{
-    hash_str, AnchoredKey, NativeOperation, NativePredicate, Operation, Params, PodType, Predicate,
-    Statement, StatementArg, ToFields, KEY_TYPE, SELF, STATEMENT_ARG_F_LEN,
+    hash_str, AnchoredKey, NativeOperation, NativePredicate, Params, PodType, Predicate, Statement,
+    StatementArg, ToFields, KEY_TYPE, SELF, STATEMENT_ARG_F_LEN,
 };
 use anyhow::Result;
 use itertools::Itertools;
@@ -134,42 +135,62 @@ impl OperationVerifyGate {
         op: &OperationTarget,
         prev_statements: &[StatementTarget],
     ) -> Result<OperationVerifyTarget> {
+        let _true = builder._true();
+        let _false = builder._false();
+        let one = builder.constant(F::ONE);
+
         // Verify that the operation `op` correctly generates the statement `st`.  The operation
         // can reference any of the `prev_statements`.
         // The verification may require aux data which needs to be stored in the
         // `OperationVerifyTarget` so that we can set during witness generation.
 
-        // TODO: Figure out the right encoding of op.code
+        // For now only support native operations
+        builder.connect(op.code[0], one);
+        let native_op = op.code[1];
+
+        let mut op_flags = Vec::new();
         let op_none = builder.constant(F::from_canonical_u64(NativeOperation::None as u64));
-        let is_none = builder.is_equal(op.code[0], op_none);
+        let is_none = builder.is_equal(native_op, op_none);
+        op_flags.push(is_none);
         let op_new_entry =
             builder.constant(F::from_canonical_u64(NativeOperation::NewEntry as u64));
-        let is_new_entry = builder.is_equal(op.code[0], op_new_entry);
+        let is_new_entry = builder.is_equal(native_op, op_new_entry);
+        op_flags.push(is_new_entry);
         let op_copy_statement =
             builder.constant(F::from_canonical_u64(NativeOperation::CopyStatement as u64));
-        let is_copy_statement = builder.is_equal(op.code[0], op_copy_statement);
+        let is_copy_statement = builder.is_equal(native_op, op_copy_statement);
+        op_flags.push(is_copy_statement);
         let op_eq_from_entries = builder.constant(F::from_canonical_u64(
             NativeOperation::EqualFromEntries as u64,
         ));
-        let is_eq_from_entries = builder.is_equal(op.code[0], op_eq_from_entries);
-        let op_gt_from_entries =
-            builder.constant(F::from_canonical_u64(NativeOperation::GtFromEntries as u64));
-        let is_gt_from_entries = builder.is_equal(op.code[0], op_gt_from_entries);
+        let is_eq_from_entries = builder.is_equal(native_op, op_eq_from_entries);
+        op_flags.push(is_eq_from_entries);
         let op_lt_from_entries =
             builder.constant(F::from_canonical_u64(NativeOperation::LtFromEntries as u64));
-        let is_lt_from_entries = builder.is_equal(op.code[0], op_lt_from_entries);
-        let op_contains_from_entries = builder.constant(F::from_canonical_u64(
-            NativeOperation::ContainsFromEntries as u64,
+        let is_lt_from_entries = builder.is_equal(native_op, op_lt_from_entries);
+        op_flags.push(is_lt_from_entries);
+        let op_not_contains_from_entries = builder.constant(F::from_canonical_u64(
+            NativeOperation::NotContainsFromEntries as u64,
         ));
-        let is_contains_from_entries = builder.is_equal(op.code[0], op_contains_from_entries);
+        let is_not_contains_from_entries =
+            builder.is_equal(native_op, op_not_contains_from_entries);
+        op_flags.push(is_not_contains_from_entries);
+
+        // One supported operation must be used.  We sum all operation flags and expect the result
+        // to be 1.  Since the flags are boolean and at most one of them is true the sum is
+        // equivalent to the OR.
+        let or_op_flags = op_flags
+            .iter()
+            .map(|b| b.target)
+            .fold(_false.target, |acc, x| builder.add(acc, x));
+        builder.connect(or_op_flags, _true.target);
 
         let ok = builder._true();
         let none_ok = self.eval_none(builder, st, op);
         let ok = builder.select_bool(is_none, none_ok, ok);
         let new_entry_ok = self.eval_new_entry(builder, st, op);
         let ok = builder.select_bool(is_new_entry, new_entry_ok, ok);
 
-        let _true = builder._true();
         builder.connect(ok.target, _true.target);
 
         Ok(OperationVerifyTarget {})
@@ -214,7 +235,8 @@ struct OperationVerifyInput {
 
 impl OperationVerifyTarget {
     fn set_targets(&self, pw: &mut PartialWitness<F>, input: &OperationVerifyInput) -> Result<()> {
-        todo!()
+        // TODO
+        Ok(())
     }
 }
 
@@ -261,8 +283,7 @@ impl MainPodVerifyGate {
             .collect();
         let id = builder.hash_n_to_hash_no_pad::<PoseidonHash>(pub_statements_flattened);
 
-        // 3. TODO check that all `input_statements` of type `ValueOf` with origin=SELF have unique
-        //    keys (no duplicates)
+        // 3. TODO check that all `input_statements` of type `ValueOf` with origin=SELF have unique keys (no duplicates).  Maybe we can do this via the NewEntry operation (check that the key doesn't exist in a previous statement with ID=SELF)
 
         // 4. Verify type
         let type_statement = &pub_statements[0];
@@ -352,6 +373,8 @@ impl MainPodVerifyCircuit {
 mod tests {
     use super::*;
     use crate::backends::plonky2::basetypes::C;
+    use crate::backends::plonky2::mock_main;
+    use crate::middleware::OperationType;
     use plonky2::plonk::{circuit_builder::CircuitBuilder, circuit_data::CircuitConfig};
 
     #[test]
@@ -384,9 +407,9 @@ mod tests {
     }
 
     fn operation_verify(
-        st: Statement,
-        op: Operation,
-        prev_statements: Vec<Statement>,
+        st: mock_main::Statement,
+        op: mock_main::Operation,
+        prev_statements: Vec<mock_main::Statement>,
     ) -> Result<()> {
         let params = Params::default();
 
@@ -429,9 +452,9 @@ mod tests {
     #[test]
     fn test_operation_verify() -> Result<()> {
         // None
-        let st = Statement::None;
-        let op = Operation::None;
-        let prev_statements = vec![Statement::None];
+        let st: mock_main::Statement = Statement::None.into();
+        let op = mock_main::Operation(OperationType::Native(NativeOperation::None), vec![]);
+        let prev_statements = vec![Statement::None.into()];
         operation_verify(st, op, prev_statements)?;
 
         Ok(())

src/backends/plonky2/mock_main/operation.rs

@@ -1,6 +1,7 @@
 use super::Statement;
-use crate::middleware::{self, OperationType};
+use crate::middleware::{self, OperationType, Params, ToFields, F};
 use anyhow::Result;
+use plonky2::field::types::{Field, PrimeField64};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
@@ -10,6 +11,16 @@ pub enum OperationArg {
     Index(usize),
 }
 
+impl ToFields for OperationArg {
+    fn to_fields(&self, _params: &Params) -> Vec<F> {
+        let f = match self {
+            Self::None => F::ZERO,
+            Self::Index(i) => F::from_canonical_usize(*i),
+        };
+        vec![f]
+    }
+}
+
 impl OperationArg {
     pub fn is_none(&self) -> bool {
         matches!(self, OperationArg::None)
@@ -20,6 +31,12 @@ impl OperationArg {
 pub struct Operation(pub OperationType, pub Vec<OperationArg>);
 
 impl Operation {
+    pub fn code(&self) -> OperationType {
+        self.0.clone()
+    }
+    pub fn args(&self) -> &[OperationArg] {
+        &self.1
+    }
     pub fn deref(&self, statements: &[Statement]) -> Result<crate::middleware::Operation> {
         let deref_args = self
             .1

src/backends/plonky2/mock_main/statement.rs

@@ -13,6 +13,9 @@ impl Statement {
     pub fn is_none(&self) -> bool {
         self.0 == Predicate::Native(NativePredicate::None)
     }
+    pub fn code(&self) -> Predicate {
+        self.0.clone()
+    }
     /// Argument method. Trailing Nones are filtered out.
     pub fn args(&self) -> Vec<StatementArg> {
         let maybe_last_arg_index = (0..self.1.len()).rev().find(|i| !self.1[*i].is_none());

src/middleware/custom.rs

@@ -49,9 +49,9 @@ impl fmt::Display for HashOrWildcard {
 }
 
 impl ToFields for HashOrWildcard {
-    fn to_fields(&self, _params: &Params) -> Vec<F> {
+    fn to_fields(&self, params: &Params) -> Vec<F> {
         match self {
-            HashOrWildcard::Hash(h) => h.to_fields(_params),
+            HashOrWildcard::Hash(h) => h.to_fields(params),
             HashOrWildcard::Wildcard(w) => (0..HASH_SIZE - 1)
                 .chain(iter::once(*w))
                 .map(|x| F::from_canonical_u64(x as u64))
@@ -91,7 +91,7 @@ impl StatementTmplArg {
 }
 
 impl ToFields for StatementTmplArg {
-    fn to_fields(&self, _params: &Params) -> Vec<F> {
+    fn to_fields(&self, params: &Params) -> Vec<F> {
         // None => (0, ...)
         // Literal(value) => (1, [value], 0, 0, 0, 0)
         // Key(hash_or_wildcard1, hash_or_wildcard2)
@@ -107,15 +107,15 @@ impl ToFields for StatementTmplArg {
             }
             StatementTmplArg::Literal(v) => {
                 let fields: Vec<F> = iter::once(F::from_canonical_u64(1))
-                    .chain(v.to_fields(_params))
+                    .chain(v.to_fields(params))
                     .chain(iter::repeat_with(|| F::from_canonical_u64(0)).take(HASH_SIZE))
                     .collect();
                 fields
             }
             StatementTmplArg::Key(hw1, hw2) => {
                 let fields: Vec<F> = iter::once(F::from_canonical_u64(2))
-                    .chain(hw1.to_fields(_params))
-                    .chain(hw2.to_fields(_params))
+                    .chain(hw1.to_fields(params))
+                    .chain(hw2.to_fields(params))
                     .collect();
                 fields
             }
@@ -318,8 +318,8 @@ impl ToFields for CustomPredicateBatch {
 }
 
 impl CustomPredicateBatch {
-    pub fn hash(&self, _params: &Params) -> Hash {
-        let input = self.to_fields(_params);
+    pub fn hash(&self, params: &Params) -> Hash {
+        let input = self.to_fields(params);
 
         hash_fields(&input)
     }
@@ -399,7 +399,7 @@ impl From<NativePredicate> for Predicate {
 }
 
 impl ToFields for Predicate {
-    fn to_fields(&self, _params: &Params) -> Vec<F> {
+    fn to_fields(&self, params: &Params) -> Vec<F> {
         // serialize:
         // NativePredicate(id) as (0, id, 0, 0, 0, 0) -- id: usize
         // BatchSelf(i) as (1, i, 0, 0, 0, 0) -- i: usize
@@ -410,13 +410,13 @@ impl ToFields for Predicate {
         // in every case: pad to (hash_size + 2) field elements
         let mut fields: Vec<F> = match self {
             Self::Native(p) => iter::once(F::from_canonical_u64(1))
-                .chain(p.to_fields(_params))
+                .chain(p.to_fields(params))
                 .collect(),
             Self::BatchSelf(i) => iter::once(F::from_canonical_u64(2))
                 .chain(iter::once(F::from_canonical_usize(*i)))
                 .collect(),
             Self::Custom(CustomPredicateRef(pb, i)) => iter::once(F::from_canonical_u64(3))
-                .chain(pb.hash(_params).0)
+                .chain(pb.hash(params).0)
                 .chain(iter::once(F::from_canonical_usize(*i)))
                 .collect(),
         };

src/middleware/operation.rs

@@ -1,7 +1,9 @@
 use anyhow::{anyhow, Result};
 use log::error;
+use plonky2::field::types::Field;
 use serde::{Deserialize, Serialize};
 use std::fmt;
+use std::iter;
 
 use super::{CustomPredicateRef, NativePredicate, Statement, StatementArg, ToFields, F};
 use crate::middleware::{AnchoredKey, Params, Predicate, Value, SELF};
@@ -14,7 +16,17 @@ pub enum OperationType {
 
 impl ToFields for OperationType {
     fn to_fields(&self, params: &Params) -> Vec<F> {
-        todo!()
+        let mut fields: Vec<F> = match self {
+            Self::Native(p) => iter::once(F::from_canonical_u64(1))
+                .chain(p.to_fields(params))
+                .collect(),
+            Self::Custom(CustomPredicateRef(pb, i)) => iter::once(F::from_canonical_u64(3))
+                .chain(pb.hash(params).0)
+                .chain(iter::once(F::from_canonical_usize(*i)))
+                .collect(),
+        };
+        fields.resize_with(Params::operation_type_size(), || F::from_canonical_u64(0));
+        fields
     }
 }
 
@@ -37,6 +49,12 @@ pub enum NativeOperation {
     MaxOf = 15,
 }
 
+impl ToFields for NativeOperation {
+    fn to_fields(&self, _params: &Params) -> Vec<F> {
+        vec![F::from_canonical_u64(*self as u64)]
+    }
+}
+
 impl OperationType {
     /// Gives the type of predicate that the operation will output, if known.
     /// CopyStatement may output any predicate (it will match the statement copied),