Merge branch 'main' into example-reorg

.github/workflows/rust.yml

@@ -198,6 +198,8 @@ jobs:
         #   chromedriver-version: "115.0.5790.102"
       - name: Install wasm32-unknown-unknown
         run: rustup target add wasm32-unknown-unknown
+      - name: Install wasm runner
+        run: cargo install wasm-server-runner
       - name: Add rust-src
         run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - name: Run wasm verifier tests
@@ -350,6 +352,9 @@ jobs:
       - name: Add wasm32-unknown-unknown target
         run: rustup target add wasm32-unknown-unknown
 
+      - name: Install wasm-server-runner
+        run: cargo install wasm-server-runner
+
       - name: Add rust-src
         run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - uses: actions/checkout@v3

.github/workflows/wasm.yml

@@ -29,6 +29,9 @@ jobs:
       - name: Add wasm32-unknown-unknown target
         run: rustup target add wasm32-unknown-unknown
 
+      - name: Install wasm-server-runner
+        run: cargo install wasm-server-runner
+
       - name: Add rust-src
         run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - name: Install binaryen

src/circuit/ops/base.rs

@@ -125,8 +125,8 @@ impl BaseOp {
             BaseOp::Sum => 1,
             BaseOp::SumInit => 1,
             BaseOp::Range { .. } => 1,
-            BaseOp::IsZero => 0,
-            BaseOp::IsBoolean => 0,
+            BaseOp::IsZero => 1,
+            BaseOp::IsBoolean => 1,
         }
     }
 

src/circuit/ops/chip.rs

@@ -276,20 +276,9 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
 
                 let constraints = match base_op {
                     BaseOp::IsBoolean => {
-                        let expected_output: Tensor<Expression<F>> = output
-                            .query_rng(meta, *block_idx, *inner_col_idx, 0, 1)
-                            .expect("non accum: output query failed");
-
-                        let output = expected_output[base_op.constraint_idx()].clone();
-
-                        vec![(output.clone()) * (output.clone() - Expression::Constant(F::from(1)))]
-                    }
-                    BaseOp::IsZero => {
-                        let expected_output: Tensor<Expression<F>> = output
-                            .query_rng(meta, *block_idx, *inner_col_idx, 0, 1)
-                            .expect("non accum: output query failed");
-                        vec![expected_output[base_op.constraint_idx()].clone()]
+                        vec![(qis[1].clone()) * (qis[1].clone() - Expression::Constant(F::from(1)))]
                     }
+                    BaseOp::IsZero => vec![qis[1].clone()],
                     _ => {
                         let expected_output: Tensor<Expression<F>> = output
                             .query_rng(meta, *block_idx, *inner_col_idx, rotation_offset, rng)
@@ -523,10 +512,10 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
 
         // we borrow mutably twice so we need to do this dance
 
-        let range_check = if let std::collections::btree_map::Entry::Vacant(e) = self.range_checks.entry(range) {
+        let range_check = if !self.range_checks.contains_key(&range) {
             // as all tables have the same input we see if there's another table who's input we can reuse
             let range_check = RangeCheck::<F>::configure(cs, range);
-            e.insert(range_check.clone());
+            self.range_checks.insert(range, range_check.clone());
             range_check
         } else {
             return Ok(());

src/circuit/ops/hybrid.rs

@@ -160,17 +160,23 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
             }
             HybridOp::ReduceArgMax { dim } => {
                 let res = tensor::ops::argmax_axes(&x, *dim)?;
+                let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                let mut inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
                 let inter =
                     Op::f(&HybridOp::ReduceMax { axes: vec![*dim] }, inputs)?.intermediate_lookups;
+                inter_equals.extend(inter);
 
-                (res, inter)
+                (res.clone(), inter_equals)
             }
             HybridOp::ReduceArgMin { dim } => {
                 let res = tensor::ops::argmin_axes(&x, *dim)?;
+                let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                let mut inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
                 let inter =
                     Op::f(&HybridOp::ReduceMin { axes: vec![*dim] }, inputs)?.intermediate_lookups;
+                inter_equals.extend(inter);
 
-                (res, inter)
+                (res.clone(), inter_equals)
             }
             HybridOp::Gather { dim, constant_idx } => {
                 if let Some(idx) = constant_idx {
@@ -179,14 +185,18 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                     (res.clone(), vec![])
                 } else {
                     let y = inputs[1].clone().map(|x| felt_to_i128(x));
+                    let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                    let inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
                     let res = tensor::ops::gather(&x, &y.map(|x| x as usize), *dim)?;
-                    (res.clone(), vec![])
+                    (res.clone(), inter_equals)
                 }
             }
-            HybridOp::OneHot { dim, num_classes } => (
-                tensor::ops::one_hot(&x, *num_classes, *dim)?.clone(),
-                vec![],
-            ),
+            HybridOp::OneHot { dim, num_classes } => {
+                let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                let inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
+                let res = tensor::ops::one_hot(&x, *num_classes, *dim)?;
+                (res.clone(), inter_equals)
+            }
             HybridOp::TopK { dim, k, largest } => {
                 let res = tensor::ops::topk_axes(&x, *k, *dim, *largest)?;
 
@@ -218,8 +228,10 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                     (res.clone(), vec![])
                 } else {
                     let y = inputs[1].clone().map(|x| felt_to_i128(x));
+                    let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                    let inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
                     let res = tensor::ops::gather_elements(&x, &y.map(|x| x as usize), *dim)?;
-                    (res.clone(), vec![])
+                    (res.clone(), inter_equals)
                 }
             }
             HybridOp::ScatterElements { dim, constant_idx } => {
@@ -231,8 +243,10 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                 } else {
                     let idx = inputs[1].clone().map(|x| felt_to_i128(x) as usize);
                     let src = inputs[2].clone().map(|x| felt_to_i128(x));
+                    let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                    let inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
                     let res = tensor::ops::scatter(&x, &idx, &src, *dim)?;
-                    (res.clone(), vec![])
+                    (res.clone(), inter_equals)
                 }
             }
             HybridOp::MaxPool2d {
@@ -427,7 +441,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                         region,
                         values.try_into()?,
                         &LookupOp::Div {
-                            denom: *denom,
+                            denom: denom.clone(),
                         },
                     )?
                 }

src/circuit/ops/layouts.rs

@@ -789,7 +789,14 @@ fn one_hot<F: PrimeField + TensorType + PartialOrd>(
     let assigned_input = region.assign(&config.inputs[0], &input)?;
 
     // now assert all elems are 0 or 1
-    let assigned_output = boolean_identity(config, region, &[output.clone()], true)?;
+    let assigned_output = region.assign(&config.inputs[1], &output)?;
+    if !region.is_dummy() {
+        for i in 0..assigned_output.len() {
+            let (x, y, z) = config.output.cartesian_coord(region.linear_coord() + i);
+            let selector = config.selectors.get(&(BaseOp::IsBoolean, x, y));
+            region.enable(selector, z)?;
+        }
+    }
     region.increment(std::cmp::max(assigned_output.len(), assigned_input.len()));
 
     let sum = sum(config, region, &[assigned_output.clone()])?;
@@ -1694,28 +1701,10 @@ pub fn equals<F: PrimeField + TensorType + PartialOrd>(
     values: &[ValTensor<F>; 2],
 ) -> Result<ValTensor<F>, Box<dyn Error>> {
     let diff = pairwise(config, region, values, BaseOp::Sub)?;
-    let diff_inverse = diff.inverse()?;
-    let product_diff_and_invert =
-        pairwise(config, region, &[diff.clone(), diff_inverse], BaseOp::Mult)?;
 
-    // constant of 1
-    let mut ones = Tensor::from(vec![ValType::Constant(F::from(1))].into_iter());
-    ones.set_visibility(&crate::graph::Visibility::Fixed);
+    let res = nonlinearity(config, region, &[diff], &LookupOp::KroneckerDelta)?;
 
-    // subtract
-    let output = pairwise(
-        config,
-        region,
-        &[ones.into(), product_diff_and_invert],
-        BaseOp::Sub,
-    )?;
-
-    // take the product of diff and output
-    let prod_check = pairwise(config, region, &[diff, output.clone()], BaseOp::Mult)?;
-
-    is_zero_identity(config, region, &[prod_check], false)?;
-
-    Ok(output)
+    Ok(res)
 }
 
 /// Xor boolean operation
@@ -1779,7 +1768,21 @@ pub fn iff<F: PrimeField + TensorType + PartialOrd>(
             .into();
 
     // make sure mask is boolean
-    let assigned_mask = boolean_identity(config, region, &[mask.clone()], true)?;
+    let assigned_mask = region.assign(&config.inputs[1], mask)?;
+
+    // Enable the selectors
+    if !region.is_dummy() {
+        (0..assigned_mask.len())
+            .map(|i| {
+                let (x, y, z) = config.inputs[1].cartesian_coord(region.linear_coord() + i);
+                let selector = config.selectors.get(&(BaseOp::IsBoolean, x, y));
+                region.enable(selector, z)?;
+                Ok(())
+            })
+            .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
+    }
+
+    region.increment(assigned_mask.len());
 
     let one_minus_mask = pairwise(config, region, &[unit, assigned_mask.clone()], BaseOp::Sub)?;
 
@@ -2380,60 +2383,18 @@ pub fn identity<F: PrimeField + TensorType + PartialOrd>(
     Ok(output)
 }
 
-/// is zero identity constraint. Usually used to constrain an instance column to an advice so the returned cells / values can be operated upon.
-pub fn is_zero_identity<F: PrimeField + TensorType + PartialOrd>(
-    config: &BaseConfig<F>,
-    region: &mut RegionCtx<F>,
-    values: &[ValTensor<F>; 1],
-    assign: bool,
-) -> Result<ValTensor<F>, Box<dyn Error>> {
-    let output = if assign || !values[0].get_const_indices()?.is_empty() {
-        let output = region.assign(&config.output, &values[0])?;
-        region.increment(output.len());
-        output
-    } else {
-        values[0].clone()
-    };
-    // Enable the selectors
-    if !region.is_dummy() {
-        (0..output.len())
-            .map(|j| {
-                let index = region.linear_coord() - j - 1;
-
-                let (x, y, z) = config.output.cartesian_coord(index);
-                let selector = config.selectors.get(&(BaseOp::IsZero, x, y));
-
-                region.enable(selector, z)?;
-                Ok(())
-            })
-            .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
-    }
-
-    Ok(output)
-}
-
 /// Boolean identity constraint. Usually used to constrain an instance column to an advice so the returned cells / values can be operated upon.
 pub fn boolean_identity<F: PrimeField + TensorType + PartialOrd>(
     config: &BaseConfig<F>,
     region: &mut RegionCtx<F>,
     values: &[ValTensor<F>; 1],
-    assign: bool,
 ) -> Result<ValTensor<F>, Box<dyn Error>> {
-    let output = if assign || !values[0].get_const_indices()?.is_empty() {
-        // get zero constants indices
-        let output = region.assign(&config.output, &values[0])?;
-        region.increment(output.len());
-        output
-    } else {
-        values[0].clone()
-    };
+    let output = region.assign(&config.inputs[1], &values[0])?;
     // Enable the selectors
     if !region.is_dummy() {
         (0..output.len())
             .map(|j| {
-                let index = region.linear_coord() - j - 1;
-
-                let (x, y, z) = config.output.cartesian_coord(index);
+                let (x, y, z) = config.inputs[1].cartesian_coord(region.linear_coord() + j);
                 let selector = config.selectors.get(&(BaseOp::IsBoolean, x, y));
 
                 region.enable(selector, z)?;
@@ -2441,6 +2402,7 @@ pub fn boolean_identity<F: PrimeField + TensorType + PartialOrd>(
             })
             .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
     }
+    region.increment(output.len());
 
     Ok(output)
 }
@@ -2509,7 +2471,7 @@ pub fn range_check<F: PrimeField + TensorType + PartialOrd>(
                 let (x, y, z) = config
                     .lookup_input
                     .cartesian_coord(region.linear_coord() + i);
-                let selector = config.range_check_selectors.get(&(*range, x, y));
+                let selector = config.range_check_selectors.get(&(range.clone(), x, y));
                 region.enable(selector, z)?;
                 Ok(())
             })
@@ -2747,8 +2709,24 @@ pub fn max<F: PrimeField + TensorType + PartialOrd>(
     )?;
     // relu(x - max(x - 1))
     let relu = nonlinearity(config, region, &[diff], &LookupOp::ReLU)?;
-    // constraining relu(x - max(x - 1)) = 0/1
-    boolean_identity(config, region, &[relu.clone()], false)?;
+
+    let len = relu.dims().iter().product();
+
+    // y_i*(1 - y_i) =0 // assert the values are either 0 or 1
+    region.assign(&config.inputs[1], &relu)?;
+
+    if !region.is_dummy() {
+        (0..len)
+            .map(|i| {
+                let (x, y, z) = config.inputs[1].cartesian_coord(region.linear_coord() + i);
+                let selector = config.selectors.get(&(BaseOp::IsBoolean, x, y));
+                region.enable(selector, z)?;
+                Ok(())
+            })
+            .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
+    }
+
+    region.increment(len);
 
     // sum(relu(x - max(x - 1)))
     let sum_relu = sum(config, region, &[relu])?;
@@ -2759,7 +2737,13 @@ pub fn max<F: PrimeField + TensorType + PartialOrd>(
         nonlinearity(config, region, &[one_minus_sum_relu], &LookupOp::ReLU)?;
 
     // constraining 1 - sum(relu(x - max(x - 1))) = 0
-    is_zero_identity(config, region, &[relu_one_minus_sum_relu], false)?;
+    region.assign(&config.inputs[1], &relu_one_minus_sum_relu)?;
+
+    let (x, y, z) = config.output.cartesian_coord(region.linear_coord());
+    let selector = config.selectors.get(&(BaseOp::IsZero, x, y));
+    region.enable(selector, z)?;
+
+    region.increment(relu_one_minus_sum_relu.len());
 
     Ok(assigned_max_val)
 }
@@ -2804,8 +2788,23 @@ pub fn min<F: PrimeField + TensorType + PartialOrd>(
 
     // relu(min(x + 1)  - x)
     let relu = nonlinearity(config, region, &[diff], &LookupOp::ReLU)?;
-    // constraining relu(min(x + 1) - x) = 0/1
-    boolean_identity(config, region, &[relu.clone()], false)?;
+
+    let len = relu.dims().iter().product();
+
+    region.assign(&config.inputs[1], &relu)?;
+    // y_i*(1 - y_i) =0 // assert the values are either 0 or 1
+    if !region.is_dummy() {
+        (0..len)
+            .map(|i| {
+                let (x, y, z) = config.inputs[1].cartesian_coord(region.linear_coord() + i);
+                let selector = config.selectors.get(&(BaseOp::IsBoolean, x, y));
+                region.enable(selector, z)?;
+                Ok(())
+            })
+            .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
+    }
+
+    region.increment(len);
 
     // sum(relu(min(x + 1) - x))
     let sum_relu = sum(config, region, &[relu])?;
@@ -2816,8 +2815,14 @@ pub fn min<F: PrimeField + TensorType + PartialOrd>(
     let relu_one_minus_sum_relu =
         nonlinearity(config, region, &[one_minus_sum_relu], &LookupOp::ReLU)?;
 
+    region.assign(&config.inputs[1], &relu_one_minus_sum_relu)?;
+
     // constraining product to 0
-    is_zero_identity(config, region, &[relu_one_minus_sum_relu], false)?;
+    let (x, y, z) = config.output.cartesian_coord(region.linear_coord());
+    let selector = config.selectors.get(&(BaseOp::IsZero, x, y));
+    region.enable(selector, z)?;
+
+    region.increment(relu_one_minus_sum_relu.len());
 
     Ok(assigned_min_val)
 }
@@ -3036,8 +3041,15 @@ pub fn range_check_percent<F: PrimeField + TensorType + PartialOrd>(
     // Add the lower_bound and upper_bound
     let sum = pairwise(config, region, &[lower_bound, upper_bound], BaseOp::Add)?;
 
+    // Assign the sum tensor to the inputs
+    region.assign(&config.inputs[1], &sum)?;
+
     // Constrain the sum to be all zeros
-    is_zero_identity(config, region, &[sum.clone()], false)?;
+    let (x, y, z) = config.output.cartesian_coord(region.linear_coord());
+    let selector = config.selectors.get(&(BaseOp::IsZero, x, y));
+    region.enable(selector, z)?;
+
+    region.increment(sum.len());
 
     Ok(sum)
 }

src/circuit/ops/mod.rs

@@ -201,7 +201,6 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for Input {
                         config,
                         region,
                         values[..].try_into()?,
-                        true,
                     )?))
                 }
                 _ => Ok(Some(super::layouts::identity(

src/execute.rs

@@ -726,11 +726,11 @@ impl AccuracyResults {
             let percentage_error = error.enum_map(|i, x| Ok::<_, TensorError>(x / original[i]))?;
             let abs_percentage_error = percentage_error.map(|x| x.abs());
 
-            errors.extend(error);
-            abs_errors.extend(abs_error);
-            squared_errors.extend(squared_error);
-            percentage_errors.extend(percentage_error);
-            abs_percentage_errors.extend(abs_percentage_error);
+            errors.extend(error.into_iter());
+            abs_errors.extend(abs_error.into_iter());
+            squared_errors.extend(squared_error.into_iter());
+            percentage_errors.extend(percentage_error.into_iter());
+            abs_percentage_errors.extend(abs_percentage_error.into_iter());
         }
 
         let mean_percent_error =

src/graph/model.rs

@@ -1173,8 +1173,8 @@ impl Model {
         );
         // set scale for HybridOp::RangeCheck and call self.conf_lookup on that op for percentage tolerance case
         let input = &vars.advices[0];
-        let output = &vars.advices[2];
-        let index = &vars.advices[1];
+        let output = &vars.advices[1];
+        let index = &vars.advices[2];
         for op in required_lookups {
             base_gate.configure_lookup(meta, input, output, index, lookup_range, logrows, &op)?;
         }

src/graph/node.rs

@@ -148,7 +148,7 @@ impl RebaseScale {
                 SupportedOp::RebaseScale(RebaseScale {
                     inner: op.inner.clone(),
                     target_scale: op.target_scale,
-                    multiplier,
+                    multiplier: multiplier,
                     rebase_op: HybridOp::Div {
                         denom: crate::circuit::utils::F32((multiplier) as f32),
                         use_range_check_for_int: !div_rebasing,

src/tensor/val.rs

@@ -871,30 +871,3 @@ impl<F: PrimeField + TensorType + PartialOrd> ValTensor<F> {
         }
     }
 }
-
-impl<F: PrimeField + TensorType + PartialOrd> ValTensor<F> {
-    /// inverts the inner values
-    pub fn inverse(&self) -> Result<ValTensor<F>, Box<dyn Error>> {
-        let mut cloned_self = self.clone();
-
-        match &mut cloned_self {
-            ValTensor::Value {
-                inner: v, dims: d, ..
-            } => {
-                *v = v.map(|x| match x {
-                    ValType::AssignedValue(v) => ValType::AssignedValue(v.invert()),
-                    ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
-                        ValType::AssignedValue(v.value_field().invert())
-                    }
-                    ValType::Value(v) => ValType::Value(v.map(|x| x.invert().unwrap_or(F::ZERO))),
-                    ValType::Constant(v) => ValType::Constant(v.invert().unwrap_or(F::ZERO)),
-                });
-                *d = v.dims().to_vec();
-            }
-            ValTensor::Instance { .. } => {
-                return Err(Box::new(TensorError::WrongMethod));
-            }
-        };
-        Ok(cloned_self)
-    }
-}

tests/integration_tests.rs

@@ -192,86 +192,86 @@ mod native_tests {
     ];
 
     const TESTS: [&str; 77] = [
-        "1l_mlp", //0
+        "1l_mlp",
         "1l_slice",
         "1l_concat",
         "1l_flatten",
         // "1l_average",
         "1l_div",
-        "1l_pad", // 5
+        "1l_pad",
         "1l_reshape",
         "1l_eltwise_div",
         "1l_sigmoid",
         "1l_sqrt",
-        "1l_softmax", //10
+        "1l_softmax",
         // "1l_instance_norm",
         "1l_batch_norm",
         "1l_prelu",
         "1l_leakyrelu",
         "1l_gelu_noappx",
         // "1l_gelu_tanh_appx",
-        "1l_relu", //15
+        "1l_relu",
         "1l_downsample",
         "1l_tanh",
         "2l_relu_sigmoid_small",
         "2l_relu_fc",
-        "2l_relu_small", //20
+        "2l_relu_small",
         "2l_relu_sigmoid",
         "1l_conv",
         "2l_sigmoid_small",
         "2l_relu_sigmoid_conv",
-        "3l_relu_conv_fc", //25
+        "3l_relu_conv_fc",
         "4l_relu_conv_fc",
         "1l_erf",
         "1l_var",
-        "1l_elu",
-        "min", //30
+        "1l_elu", //30
+        "min",
         "max",
         "1l_max_pool",
         "1l_conv_transpose",
-        "1l_upsample",
-        "1l_identity", //35
+        "1l_upsample", //35
+        "1l_identity",
         "idolmodel",
         "trig",
         "prelu_gmm",
-        "lstm",
-        "rnn", //40
+        "lstm", //40
+        "rnn",
         "quantize_dequantize",
         "1l_where",
         "boolean",
         "boolean_identity",
-        "decision_tree", // 45
+        "decision_tree", // "variable_cnn",
         "random_forest",
         "gradient_boosted_trees",
         "1l_topk",
-        "xgboost",
-        "lightgbm", //50
+        "xgboost", //50
+        "lightgbm",
         "hummingbird_decision_tree",
         "oh_decision_tree",
         "linear_svc",
         "gather_elements",
-        "less", //55
+        "less",
         "xgboost_reg",
         "1l_powf",
         "scatter_elements",
-        "1l_linear",
-        "linear_regression", //60
+        "1l_linear", //60
+        "linear_regression",
         "sklearn_mlp",
         "1l_mean",
         "rounding_ops",
         // "mean_as_constrain",
         "arange",
-        "layernorm", //65
+        "layernorm",
         "bitwise_ops",
         "blackman_window",
-        "softsign", //68
+        "softsign", //70
         "softplus",
-        "selu", //70
+        "selu",
         "hard_sigmoid",
         "log_softmax",
         "eye",
         "ltsf",
-        "remainder", //75
+        "remainder",
         "bitshift",
     ];