refactor: equals argument without lookups (#705 )

refactor: range check recip (#703 )
2026-01-14 00:38:15 -05:00 · 2024-02-07 14:20:13 +00:00 · 2024-02-05 14:42:26 +00:00
21 changed files with 583 additions and 512 deletions
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -198,8 +198,6 @@ 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
@@ -352,9 +350,6 @@ 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
--- a/.github/workflows/wasm.yml
+++ b/.github/workflows/wasm.yml
@@ -29,9 +29,6 @@ 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
--- a/src/circuit/ops/base.rs
+++ b/src/circuit/ops/base.rs
@@ -125,8 +125,8 @@ impl BaseOp {
            BaseOp::Sum => 1,
            BaseOp::SumInit => 1,
            BaseOp::Range { .. } => 1,
-            BaseOp::IsZero => 1,
-            BaseOp::IsBoolean => 1,
+            BaseOp::IsZero => 0,
+            BaseOp::IsBoolean => 0,
        }
    }

--- a/src/circuit/ops/chip.rs
+++ b/src/circuit/ops/chip.rs
@@ -276,9 +276,20 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {

                let constraints = match base_op {
                    BaseOp::IsBoolean => {
-                        vec![(qis[1].clone()) * (qis[1].clone() - Expression::Constant(F::from(1)))]
+                        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()]
                    }
-                    BaseOp::IsZero => vec![qis[1].clone()],
                    _ => {
                        let expected_output: Tensor<Expression<F>> = output
                            .query_rng(meta, *block_idx, *inner_col_idx, rotation_offset, rng)
@@ -512,10 +523,10 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {

        // we borrow mutably twice so we need to do this dance

-        let range_check = if !self.range_checks.contains_key(&range) {
+        let range_check = if let std::collections::btree_map::Entry::Vacant(e) = self.range_checks.entry(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);
-            self.range_checks.insert(range, range_check.clone());
+            e.insert(range_check.clone());
            range_check
        } else {
            return Ok(());
--- a/src/circuit/ops/hybrid.rs
+++ b/src/circuit/ops/hybrid.rs
@@ -1,7 +1,8 @@
 use super::*;
 use crate::{
-    circuit::{self, layouts, utils, Tolerance},
+    circuit::{layouts, utils, Tolerance},
    fieldutils::{felt_to_i128, i128_to_felt},
+    graph::multiplier_to_scale,
    tensor::{self, Tensor, TensorError, TensorType, ValTensor},
 };
 use halo2curves::ff::PrimeField;
@@ -13,6 +14,11 @@ use serde::{Deserialize, Serialize};
 /// An enum representing the operations that consist of both lookups and arithmetic operations.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum HybridOp {
+    Recip {
+        input_scale: utils::F32,
+        output_scale: utils::F32,
+        use_range_check_for_int: bool,
+    },
    Div {
        denom: utils::F32,
        use_range_check_for_int: bool,
@@ -79,6 +85,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
        match self {
            HybridOp::Greater | HybridOp::Less | HybridOp::Equals => vec![0, 1],
            HybridOp::ScatterElements { .. } => vec![0, 2],
+            HybridOp::GreaterEqual | HybridOp::LessEqual => vec![0, 1],
            _ => vec![],
        }
    }
@@ -122,35 +129,48 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                use_range_check_for_int,
                ..
            } => {
+                let res = crate::tensor::ops::nonlinearities::const_div(&x, denom.0 as f64);
                // if denom is a round number and use_range_check_for_int is true, use range check check
                if denom.0.fract() == 0.0 && *use_range_check_for_int {
-                    let divisor = Tensor::from(vec![denom.0 as i128].into_iter());
-                    let res = crate::tensor::ops::div(&[x, divisor.clone()])?;
+                    let divisor = Tensor::from(vec![denom.0 as i128 / 2].into_iter());
                    (res, vec![-divisor.clone(), divisor])
                } else {
-                    let res = crate::tensor::ops::nonlinearities::const_div(&x, denom.0 as f64);
+                    (res, vec![x])
+                }
+            }
+            HybridOp::Recip {
+                input_scale,
+                output_scale,
+                use_range_check_for_int,
+            } => {
+                let res = crate::tensor::ops::nonlinearities::recip(
+                    &x,
+                    input_scale.0 as f64,
+                    output_scale.0 as f64,
+                );
+                // if scale is a round number and use_range_check_for_int is true, use range check check
+                if input_scale.0.fract() == 0.0 && *use_range_check_for_int {
+                    let err_tol = Tensor::from(
+                        vec![(output_scale.0 * input_scale.0) as i128 / 2].into_iter(),
+                    );
+                    (res, vec![-err_tol.clone(), err_tol])
+                } else {
                    (res, vec![x])
                }
            }
            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.clone(), inter_equals)
+                (res, inter)
            }
            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.clone(), inter_equals)
+                (res, inter)
            }
            HybridOp::Gather { dim, constant_idx } => {
                if let Some(idx) = constant_idx {
@@ -159,18 +179,14 @@ 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(), inter_equals)
+                    (res.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::OneHot { dim, num_classes } => (
+                tensor::ops::one_hot(&x, *num_classes, *dim)?.clone(),
+                vec![],
+            ),
            HybridOp::TopK { dim, k, largest } => {
                let res = tensor::ops::topk_axes(&x, *k, *dim, *largest)?;

@@ -202,10 +218,8 @@ 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(), inter_equals)
+                    (res.clone(), vec![])
                }
            }
            HybridOp::ScatterElements { dim, constant_idx } => {
@@ -217,10 +231,8 @@ 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(), inter_equals)
+                    (res.clone(), vec![])
                }
            }
            HybridOp::MaxPool2d {
@@ -291,6 +303,14 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {

    fn as_string(&self) -> String {
        match self {
+            HybridOp::Recip {
+                input_scale,
+                output_scale,
+                use_range_check_for_int,
+            } => format!(
+                "RECIP (input_scale={}, output_scale={}, use_range_check_for_int={})",
+                input_scale, output_scale, use_range_check_for_int
+            ),
            HybridOp::Div {
                denom,
                use_range_check_for_int,
@@ -361,6 +381,34 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                *kernel_shape,
                *normalized,
            )?,
+            HybridOp::Recip {
+                input_scale,
+                output_scale,
+                use_range_check_for_int,
+            } => {
+                if input_scale.0.fract() == 0.0
+                    && output_scale.0.fract() == 0.0
+                    && *use_range_check_for_int
+                {
+                    layouts::recip(
+                        config,
+                        region,
+                        values[..].try_into()?,
+                        i128_to_felt(input_scale.0 as i128),
+                        i128_to_felt(output_scale.0 as i128),
+                    )?
+                } else {
+                    layouts::nonlinearity(
+                        config,
+                        region,
+                        values.try_into()?,
+                        &LookupOp::Recip {
+                            input_scale: *input_scale,
+                            output_scale: *output_scale,
+                        },
+                    )?
+                }
+            }
            HybridOp::Div {
                denom,
                use_range_check_for_int,
@@ -379,7 +427,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                        region,
                        values.try_into()?,
                        &LookupOp::Div {
-                            denom: denom.clone(),
+                            denom: *denom,
                        },
                    )?
                }
@@ -471,116 +519,12 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
            | HybridOp::OneHot { .. }
            | HybridOp::ReduceArgMin { .. } => 0,
            HybridOp::Softmax { .. } => 2 * in_scales[0],
+            HybridOp::Recip { output_scale, .. } => multiplier_to_scale(output_scale.0 as f64),
            _ => in_scales[0],
        };
        Ok(scale)
    }

-    fn required_range_checks(&self) -> Vec<Range> {
-        match self {
-            HybridOp::Div {
-                denom,
-                use_range_check_for_int,
-                ..
-            } => {
-                if denom.0.fract() == 0.0 && *use_range_check_for_int {
-                    vec![(-denom.0 as i128 + 1, denom.0 as i128 - 1)]
-                } else {
-                    vec![]
-                }
-            }
-            _ => vec![],
-        }
-    }
-
-    fn required_lookups(&self) -> Vec<LookupOp> {
-        match self {
-            HybridOp::ReduceMax { .. }
-            | HybridOp::ReduceMin { .. }
-            | HybridOp::MaxPool2d { .. } => Op::<F>::required_lookups(&LookupOp::ReLU),
-            HybridOp::Div {
-                denom,
-                use_range_check_for_int,
-                ..
-            } => {
-                if denom.0.fract() == 0.0 && *use_range_check_for_int {
-                    vec![]
-                } else {
-                    vec![LookupOp::Div {
-                        denom: denom.clone(),
-                    }]
-                }
-            }
-            HybridOp::Softmax { scale, .. } => {
-                vec![
-                    LookupOp::Exp { scale: *scale },
-                    LookupOp::Recip {
-                        scale: scale.0.powf(2.0).into(),
-                    },
-                ]
-            }
-            HybridOp::RangeCheck(tol) => {
-                let mut lookups = vec![];
-                if tol.val > 0.0 {
-                    let scale_squared = tol.scale.0.powf(2.0);
-                    lookups.extend([
-                        LookupOp::Recip {
-                            scale: scale_squared.into(),
-                        },
-                        LookupOp::GreaterThan {
-                            a: circuit::utils::F32((tol.val * scale_squared) / 100.0),
-                        },
-                    ]);
-                }
-                lookups
-            }
-            HybridOp::Greater { .. } | HybridOp::Less { .. } => {
-                vec![LookupOp::GreaterThan {
-                    a: circuit::utils::F32(0.),
-                }]
-            }
-            HybridOp::GreaterEqual { .. } | HybridOp::LessEqual { .. } => {
-                vec![LookupOp::GreaterThanEqual {
-                    a: circuit::utils::F32(0.),
-                }]
-            }
-            HybridOp::TopK { .. } => {
-                vec![
-                    LookupOp::GreaterThan {
-                        a: circuit::utils::F32(0.),
-                    },
-                    LookupOp::KroneckerDelta,
-                ]
-            }
-            HybridOp::Gather {
-                constant_idx: None, ..
-            }
-            | HybridOp::OneHot { .. }
-            | HybridOp::GatherElements {
-                constant_idx: None, ..
-            }
-            | HybridOp::ScatterElements {
-                constant_idx: None, ..
-            }
-            | HybridOp::Equals { .. } => {
-                vec![LookupOp::KroneckerDelta]
-            }
-            HybridOp::ReduceArgMax { .. } | HybridOp::ReduceArgMin { .. } => {
-                vec![LookupOp::ReLU, LookupOp::KroneckerDelta]
-            }
-            HybridOp::SumPool {
-                kernel_shape,
-                normalized: true,
-                ..
-            } => {
-                vec![LookupOp::Div {
-                    denom: utils::F32((kernel_shape.0 * kernel_shape.1) as f32),
-                }]
-            }
-            _ => vec![],
-        }
-    }
-
    fn clone_dyn(&self) -> Box<dyn Op<F>> {
        Box::new(self.clone()) // Forward to the derive(Clone) impl
    }
--- a/src/circuit/ops/layouts.rs
+++ b/src/circuit/ops/layouts.rs
@@ -18,7 +18,10 @@ use super::{
    region::RegionCtx,
 };
 use crate::{
-    circuit::{ops::base::BaseOp, utils},
+    circuit::{
+        ops::base::BaseOp,
+        utils::{self},
+    },
    fieldutils::{felt_to_i128, i128_to_felt},
    tensor::{
        get_broadcasted_shape,
@@ -61,7 +64,7 @@ pub fn div<F: PrimeField + TensorType + PartialOrd>(
    let input = value[0].clone();
    let input_dims = input.dims();

-    let range_check_bracket = felt_to_i128(div) - 1;
+    let range_check_bracket = felt_to_i128(div) / 2;

    let mut divisor = Tensor::from(vec![ValType::Constant(div)].into_iter());
    divisor.set_visibility(&crate::graph::Visibility::Fixed);
@@ -72,8 +75,7 @@ pub fn div<F: PrimeField + TensorType + PartialOrd>(

    let mut claimed_output: ValTensor<F> = if is_assigned {
        let input_evals = input.get_int_evals()?;
-        let divisor_evals = divisor.get_int_evals()?;
-        tensor::ops::div(&[input_evals.clone(), divisor_evals.clone()])?
+        tensor::ops::nonlinearities::const_div(&input_evals.clone(), felt_to_i128(div) as f64)
            .iter()
            .map(|x| Ok(Value::known(i128_to_felt(*x))))
            .collect::<Result<Tensor<Value<F>>, Box<dyn Error>>>()?
@@ -94,6 +96,8 @@ pub fn div<F: PrimeField + TensorType + PartialOrd>(
        BaseOp::Mult,
    )?;

+    log::debug!("product: {:?}", product.get_int_evals()?);
+
    let diff_with_input = pairwise(
        config,
        region,
@@ -111,6 +115,83 @@ pub fn div<F: PrimeField + TensorType + PartialOrd>(
    Ok(claimed_output)
 }

+/// recip accumulated layout
+pub fn recip<F: PrimeField + TensorType + PartialOrd>(
+    config: &BaseConfig<F>,
+    region: &mut RegionCtx<F>,
+    value: &[ValTensor<F>; 1],
+    input_scale: F,
+    output_scale: F,
+) -> Result<ValTensor<F>, Box<dyn Error>> {
+    let input = value[0].clone();
+    let input_dims = input.dims();
+
+    let range_check_bracket = felt_to_i128(output_scale * input_scale) / 2;
+
+    let mut scaled_unit =
+        Tensor::from(vec![ValType::Constant(output_scale * input_scale)].into_iter());
+    scaled_unit.set_visibility(&crate::graph::Visibility::Fixed);
+    let scaled_unit = region.assign(&config.inputs[1], &scaled_unit.into())?;
+    region.increment(scaled_unit.len());
+
+    let is_assigned = !input.any_unknowns()? && !scaled_unit.any_unknowns()?;
+
+    let mut claimed_output: ValTensor<F> = if is_assigned {
+        let input_evals = input.get_int_evals()?;
+        tensor::ops::nonlinearities::recip(
+            &input_evals,
+            felt_to_i128(input_scale) as f64,
+            felt_to_i128(output_scale) as f64,
+        )
+        .iter()
+        .map(|x| Ok(Value::known(i128_to_felt(*x))))
+        .collect::<Result<Tensor<Value<F>>, Box<dyn Error>>>()?
+        .into()
+    } else {
+        Tensor::new(
+            Some(&vec![Value::<F>::unknown(); input.len()]),
+            &[input.len()],
+        )?
+        .into()
+    };
+    claimed_output.reshape(input_dims)?;
+
+    // this is now of scale 2 * scale
+    let product = pairwise(
+        config,
+        region,
+        &[claimed_output.clone(), input.clone()],
+        BaseOp::Mult,
+    )?;
+
+    log::debug!("product: {:?}", product.get_int_evals()?);
+
+    // this is now of scale 2 * scale hence why we rescaled the unit scale
+    let diff_with_input = pairwise(
+        config,
+        region,
+        &[product.clone(), scaled_unit.clone()],
+        BaseOp::Sub,
+    )?;
+
+    log::debug!("scaled_unit: {:?}", scaled_unit.get_int_evals()?);
+
+    // debug print the diff
+    log::debug!("diff_with_input: {:?}", diff_with_input.get_int_evals()?);
+
+    log::debug!("range_check_bracket: {:?}", range_check_bracket);
+
+    // at most the error should be in the original unit scale's range
+    range_check(
+        config,
+        region,
+        &[diff_with_input],
+        &(-range_check_bracket, range_check_bracket),
+    )?;
+
+    Ok(claimed_output)
+}
+
 /// Dot product accumulated layout
 pub fn dot<F: PrimeField + TensorType + PartialOrd>(
    config: &BaseConfig<F>,
@@ -708,14 +789,7 @@ 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 = 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)?;
-        }
-    }
+    let assigned_output = boolean_identity(config, region, &[output.clone()], true)?;
    region.increment(std::cmp::max(assigned_output.len(), assigned_input.len()));

    let sum = sum(config, region, &[assigned_output.clone()])?;
@@ -1620,10 +1694,28 @@ 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)?;

-    let res = nonlinearity(config, region, &[diff], &LookupOp::KroneckerDelta)?;
+    // constant of 1
+    let mut ones = Tensor::from(vec![ValType::Constant(F::from(1))].into_iter());
+    ones.set_visibility(&crate::graph::Visibility::Fixed);

-    Ok(res)
+    // 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)
 }

 /// Xor boolean operation
@@ -1687,21 +1779,7 @@ pub fn iff<F: PrimeField + TensorType + PartialOrd>(
            .into();

    // make sure mask is boolean
-    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 assigned_mask = boolean_identity(config, region, &[mask.clone()], true)?;

    let one_minus_mask = pairwise(config, region, &[unit, assigned_mask.clone()], BaseOp::Sub)?;

@@ -2302,18 +2380,60 @@ 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 = region.assign(&config.inputs[1], &values[0])?;
+    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()
+    };
    // Enable the selectors
    if !region.is_dummy() {
        (0..output.len())
            .map(|j| {
-                let (x, y, z) = config.inputs[1].cartesian_coord(region.linear_coord() + j);
+                let index = region.linear_coord() - j - 1;
+
+                let (x, y, z) = config.output.cartesian_coord(index);
                let selector = config.selectors.get(&(BaseOp::IsBoolean, x, y));

                region.enable(selector, z)?;
@@ -2321,7 +2441,6 @@ pub fn boolean_identity<F: PrimeField + TensorType + PartialOrd>(
            })
            .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
    }
-    region.increment(output.len());

    Ok(output)
 }
@@ -2371,6 +2490,8 @@ pub fn range_check<F: PrimeField + TensorType + PartialOrd>(
    values: &[ValTensor<F>; 1],
    range: &crate::circuit::table::Range,
 ) -> Result<ValTensor<F>, Box<dyn Error>> {
+    region.add_used_range_check(*range);
+
    // time the entire operation
    let timer = instant::Instant::now();

@@ -2388,7 +2509,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.clone(), x, y));
+                let selector = config.range_check_selectors.get(&(*range, x, y));
                region.enable(selector, z)?;
                Ok(())
            })
@@ -2415,6 +2536,8 @@ pub fn nonlinearity<F: PrimeField + TensorType + PartialOrd>(
    values: &[ValTensor<F>; 1],
    nl: &LookupOp,
 ) -> Result<ValTensor<F>, Box<dyn Error>> {
+    region.add_used_lookup(nl.clone());
+
    // time the entire operation
    let timer = instant::Instant::now();

@@ -2624,24 +2747,8 @@ pub fn max<F: PrimeField + TensorType + PartialOrd>(
    )?;
    // relu(x - max(x - 1))
    let relu = nonlinearity(config, region, &[diff], &LookupOp::ReLU)?;
-
-    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);
+    // constraining relu(x - max(x - 1)) = 0/1
+    boolean_identity(config, region, &[relu.clone()], false)?;

    // sum(relu(x - max(x - 1)))
    let sum_relu = sum(config, region, &[relu])?;
@@ -2652,13 +2759,7 @@ 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
-    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());
+    is_zero_identity(config, region, &[relu_one_minus_sum_relu], false)?;

    Ok(assigned_max_val)
 }
@@ -2703,23 +2804,8 @@ pub fn min<F: PrimeField + TensorType + PartialOrd>(

    // relu(min(x + 1)  - x)
    let relu = nonlinearity(config, region, &[diff], &LookupOp::ReLU)?;
-
-    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);
+    // constraining relu(min(x + 1) - x) = 0/1
+    boolean_identity(config, region, &[relu.clone()], false)?;

    // sum(relu(min(x + 1) - x))
    let sum_relu = sum(config, region, &[relu])?;
@@ -2730,14 +2816,8 @@ 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
-    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());
+    is_zero_identity(config, region, &[relu_one_minus_sum_relu], false)?;

    Ok(assigned_min_val)
 }
@@ -2884,7 +2964,8 @@ pub fn softmax<F: PrimeField + TensorType + PartialOrd>(
        &[denom],
        // we set to input scale + output_scale so the output scale is output)scale
        &LookupOp::Recip {
-            scale: scale.0.powf(2.0).into(),
+            input_scale: scale,
+            output_scale: scale,
        },
    )?;

@@ -2912,19 +2993,22 @@ pub fn range_check_percent<F: PrimeField + TensorType + PartialOrd>(
    // Calculate the difference between the expected output and actual output
    let diff = pairwise(config, region, values, BaseOp::Sub)?;

-    let scale_squared = scale.0.powf(2.0);
    // Calculate the reciprocal of the expected output tensor, scaling by double the scaling factor
    let recip = nonlinearity(
        config,
        region,
        &[values[0].clone()],
        &LookupOp::Recip {
-            scale: scale_squared.into(),
+            input_scale: scale,
+            output_scale: scale,
        },
    )?;
+
    // Multiply the difference by the recip
    let product = pairwise(config, region, &[diff, recip], BaseOp::Mult)?;

+    let scale_squared = scale.0 * scale.0;
+
    // Use the greater than look up table to check if the percent error is within the tolerance for upper bound
    let tol = tol / 100.0;
    let upper_bound = nonlinearity(
@@ -2952,15 +3036,8 @@ 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
-    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());
+    is_zero_identity(config, region, &[sum.clone()], false)?;

    Ok(sum)
 }
--- a/src/circuit/ops/lookup.rs
+++ b/src/circuit/ops/lookup.rs
@@ -5,7 +5,7 @@ use std::error::Error;
 use crate::{
    circuit::{layouts, table::Range, utils},
    fieldutils::{felt_to_i128, i128_to_felt},
-    graph::{multiplier_to_scale, scale_to_multiplier},
+    graph::multiplier_to_scale,
    tensor::{self, Tensor, TensorError, TensorType},
 };

@@ -17,42 +17,112 @@ use halo2curves::ff::PrimeField;
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
 pub enum LookupOp {
    Abs,
-    Div { denom: utils::F32 },
-    Cast { scale: utils::F32 },
+    Div {
+        denom: utils::F32,
+    },
+    Cast {
+        scale: utils::F32,
+    },
    ReLU,
-    Max { scale: utils::F32, a: utils::F32 },
-    Min { scale: utils::F32, a: utils::F32 },
-    Ceil { scale: utils::F32 },
-    Floor { scale: utils::F32 },
-    Round { scale: utils::F32 },
-    RoundHalfToEven { scale: utils::F32 },
-    Sqrt { scale: utils::F32 },
-    Rsqrt { scale: utils::F32 },
-    Recip { scale: utils::F32 },
-    LeakyReLU { slope: utils::F32 },
-    Sigmoid { scale: utils::F32 },
-    Ln { scale: utils::F32 },
-    Exp { scale: utils::F32 },
-    Cos { scale: utils::F32 },
-    ACos { scale: utils::F32 },
-    Cosh { scale: utils::F32 },
-    ACosh { scale: utils::F32 },
-    Sin { scale: utils::F32 },
-    ASin { scale: utils::F32 },
-    Sinh { scale: utils::F32 },
-    ASinh { scale: utils::F32 },
-    Tan { scale: utils::F32 },
-    ATan { scale: utils::F32 },
-    Tanh { scale: utils::F32 },
-    ATanh { scale: utils::F32 },
-    Erf { scale: utils::F32 },
-    GreaterThan { a: utils::F32 },
-    LessThan { a: utils::F32 },
-    GreaterThanEqual { a: utils::F32 },
-    LessThanEqual { a: utils::F32 },
+    Max {
+        scale: utils::F32,
+        a: utils::F32,
+    },
+    Min {
+        scale: utils::F32,
+        a: utils::F32,
+    },
+    Ceil {
+        scale: utils::F32,
+    },
+    Floor {
+        scale: utils::F32,
+    },
+    Round {
+        scale: utils::F32,
+    },
+    RoundHalfToEven {
+        scale: utils::F32,
+    },
+    Sqrt {
+        scale: utils::F32,
+    },
+    Rsqrt {
+        scale: utils::F32,
+    },
+    Recip {
+        input_scale: utils::F32,
+        output_scale: utils::F32,
+    },
+    LeakyReLU {
+        slope: utils::F32,
+    },
+    Sigmoid {
+        scale: utils::F32,
+    },
+    Ln {
+        scale: utils::F32,
+    },
+    Exp {
+        scale: utils::F32,
+    },
+    Cos {
+        scale: utils::F32,
+    },
+    ACos {
+        scale: utils::F32,
+    },
+    Cosh {
+        scale: utils::F32,
+    },
+    ACosh {
+        scale: utils::F32,
+    },
+    Sin {
+        scale: utils::F32,
+    },
+    ASin {
+        scale: utils::F32,
+    },
+    Sinh {
+        scale: utils::F32,
+    },
+    ASinh {
+        scale: utils::F32,
+    },
+    Tan {
+        scale: utils::F32,
+    },
+    ATan {
+        scale: utils::F32,
+    },
+    Tanh {
+        scale: utils::F32,
+    },
+    ATanh {
+        scale: utils::F32,
+    },
+    Erf {
+        scale: utils::F32,
+    },
+    GreaterThan {
+        a: utils::F32,
+    },
+    LessThan {
+        a: utils::F32,
+    },
+    GreaterThanEqual {
+        a: utils::F32,
+    },
+    LessThanEqual {
+        a: utils::F32,
+    },
    Sign,
    KroneckerDelta,
-    Pow { scale: utils::F32, a: utils::F32 },
+    Pow {
+        scale: utils::F32,
+        a: utils::F32,
+    },
 }

 impl LookupOp {
@@ -120,7 +190,14 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
                &x,
                f32::from(*scale).into(),
            )),
-            LookupOp::Recip { scale } => Ok(tensor::ops::nonlinearities::recip(&x, scale.into())),
+            LookupOp::Recip {
+                input_scale,
+                output_scale,
+            } => Ok(tensor::ops::nonlinearities::recip(
+                &x,
+                input_scale.into(),
+                output_scale.into(),
+            )),
            LookupOp::ReLU => Ok(tensor::ops::nonlinearities::leakyrelu(&x, 0_f64)),

            LookupOp::LeakyReLU { slope: a } => {
@@ -173,7 +250,13 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
            LookupOp::GreaterThanEqual { .. } => "GREATER_THAN_EQUAL".into(),
            LookupOp::LessThan { .. } => "LESS_THAN".into(),
            LookupOp::LessThanEqual { .. } => "LESS_THAN_EQUAL".into(),
-            LookupOp::Recip { scale, .. } => format!("RECIP(scale={})", scale),
+            LookupOp::Recip {
+                input_scale,
+                output_scale,
+            } => format!(
+                "RECIP(input_scale={}, output_scale={})",
+                input_scale, output_scale
+            ),
            LookupOp::Div { denom, .. } => format!("DIV(denom={})", denom),
            LookupOp::Cast { scale } => format!("CAST(scale={})", scale),
            LookupOp::Ln { scale } => format!("LN(scale={})", scale),
@@ -220,12 +303,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
                let in_scale = inputs_scale[0];
                in_scale + multiplier_to_scale(1. / scale.0 as f64)
            }
-            LookupOp::Recip { scale } => {
-                let mut out_scale = inputs_scale[0];
-                out_scale +=
-                    multiplier_to_scale(scale.0 as f64 / scale_to_multiplier(out_scale).powf(2.0));
-                out_scale
-            }
+            LookupOp::Recip { output_scale, .. } => multiplier_to_scale(output_scale.into()),
            LookupOp::Sign
            | LookupOp::GreaterThan { .. }
            | LookupOp::LessThan { .. }
@@ -237,10 +315,6 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
        Ok(scale)
    }

-    fn required_lookups(&self) -> Vec<LookupOp> {
-        vec![self.clone()]
-    }
-
    fn clone_dyn(&self) -> Box<dyn Op<F>> {
        Box::new(self.clone()) // Forward to the derive(Clone) impl
    }
--- a/src/circuit/ops/mod.rs
+++ b/src/circuit/ops/mod.rs
@@ -10,8 +10,6 @@ use halo2curves::ff::PrimeField;

 use self::{lookup::LookupOp, region::RegionCtx};

-use super::table::Range;
-
 ///
 pub mod base;
 ///
@@ -57,16 +55,6 @@ pub trait Op<F: PrimeField + TensorType + PartialOrd>: std::fmt::Debug + Send +
        vec![]
    }

-    /// Returns the lookups required by the operation.
-    fn required_lookups(&self) -> Vec<LookupOp> {
-        vec![]
-    }
-
-    /// Returns the range checks required by the operation.
-    fn required_range_checks(&self) -> Vec<Range> {
-        vec![]
-    }
-
    /// Returns true if the operation is an input.
    fn is_input(&self) -> bool {
        false
@@ -213,6 +201,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for Input {
                        config,
                        region,
                        values[..].try_into()?,
+                        true,
                    )?))
                }
                _ => Ok(Some(super::layouts::identity(
--- a/src/circuit/ops/region.rs
+++ b/src/circuit/ops/region.rs
@@ -1,4 +1,7 @@
-use crate::tensor::{Tensor, TensorError, TensorType, ValTensor, ValType, VarTensor};
+use crate::{
+    circuit::table::Range,
+    tensor::{Tensor, TensorError, TensorType, ValTensor, ValType, VarTensor},
+};
 use halo2_proofs::{
    circuit::Region,
    plonk::{Error, Selector},
@@ -7,9 +10,14 @@ use halo2curves::ff::PrimeField;
 use std::{
    cell::RefCell,
    collections::HashSet,
-    sync::atomic::{AtomicUsize, Ordering},
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc, Mutex,
+    },
 };

+use super::lookup::LookupOp;
+
 /// Region error
 #[derive(Debug, thiserror::Error)]
 pub enum RegionError {
@@ -56,6 +64,8 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd> {
    linear_coord: usize,
    num_inner_cols: usize,
    total_constants: usize,
+    used_lookups: HashSet<LookupOp>,
+    used_range_checks: HashSet<Range>,
 }

 impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
@@ -75,6 +85,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            row,
            linear_coord,
            total_constants: 0,
+            used_lookups: HashSet::new(),
+            used_range_checks: HashSet::new(),
        }
    }
    /// Create a new region context from a wrapped region
@@ -90,6 +102,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            linear_coord,
            row,
            total_constants: 0,
+            used_lookups: HashSet::new(),
+            used_range_checks: HashSet::new(),
        }
    }

@@ -104,6 +118,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            linear_coord,
            row,
            total_constants: 0,
+            used_lookups: HashSet::new(),
+            used_range_checks: HashSet::new(),
        }
    }

@@ -111,8 +127,10 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
    pub fn new_dummy_with_constants(
        row: usize,
        linear_coord: usize,
-        constants: usize,
+        total_constants: usize,
        num_inner_cols: usize,
+        used_lookups: HashSet<LookupOp>,
+        used_range_checks: HashSet<Range>,
    ) -> RegionCtx<'a, F> {
        let region = None;
        RegionCtx {
@@ -120,7 +138,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            num_inner_cols,
            linear_coord,
            row,
-            total_constants: constants,
+            total_constants,
+            used_lookups,
+            used_range_checks,
        }
    }

@@ -170,6 +190,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        let row = AtomicUsize::new(self.row());
        let linear_coord = AtomicUsize::new(self.linear_coord());
        let constants = AtomicUsize::new(self.total_constants());
+        let lookups = Arc::new(Mutex::new(self.used_lookups.clone()));
+        let range_checks = Arc::new(Mutex::new(self.used_range_checks.clone()));

        *output = output
            .par_enum_map(|idx, _| {
@@ -177,12 +199,16 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
                let starting_offset = row.load(Ordering::SeqCst);
                let starting_linear_coord = linear_coord.load(Ordering::SeqCst);
                let starting_constants = constants.load(Ordering::SeqCst);
+                // get inner value of the locked lookups
+
                // we need to make sure that the region is not shared between threads
                let mut local_reg = Self::new_dummy_with_constants(
                    starting_offset,
                    starting_linear_coord,
                    starting_constants,
                    self.num_inner_cols,
+                    HashSet::new(),
+                    HashSet::new(),
                );
                let res = inner_loop_function(idx, &mut local_reg);
                // we update the offset and constants
@@ -195,6 +221,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
                    local_reg.total_constants() - starting_constants,
                    Ordering::SeqCst,
                );
+                // update the lookups
+                let mut lookups = lookups.lock().unwrap();
+                lookups.extend(local_reg.used_lookups());
+                let mut range_checks = range_checks.lock().unwrap();
+                range_checks.extend(local_reg.used_range_checks());
                res
            })
            .map_err(|e| {
@@ -204,6 +235,21 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        self.total_constants = constants.into_inner();
        self.linear_coord = linear_coord.into_inner();
        self.row = row.into_inner();
+        self.used_lookups = Arc::try_unwrap(lookups)
+            .map_err(|e| RegionError::from(format!("dummy_loop: failed to get lookups: {:?}", e)))?
+            .into_inner()
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get lookups: {:?}", e))
+            })?;
+        self.used_range_checks = Arc::try_unwrap(range_checks)
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get range checks: {:?}", e))
+            })?
+            .into_inner()
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get range checks: {:?}", e))
+            })?;
+
        Ok(())
    }

@@ -212,15 +258,14 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        self.region.is_none()
    }

-    /// duplicate_dummy
-    pub fn duplicate_dummy(&self) -> Self {
-        Self {
-            region: None,
-            linear_coord: self.linear_coord,
-            num_inner_cols: self.num_inner_cols,
-            row: self.row,
-            total_constants: self.total_constants,
-        }
+    /// add used lookup
+    pub fn add_used_lookup(&mut self, lookup: LookupOp) {
+        self.used_lookups.insert(lookup);
+    }
+
+    /// add used range check
+    pub fn add_used_range_check(&mut self, range: Range) {
+        self.used_range_checks.insert(range);
    }

    /// Get the offset
@@ -238,6 +283,16 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        self.total_constants
    }

+    /// get used lookups
+    pub fn used_lookups(&self) -> HashSet<LookupOp> {
+        self.used_lookups.clone()
+    }
+
+    /// get used range checks
+    pub fn used_range_checks(&self) -> HashSet<Range> {
+        self.used_range_checks.clone()
+    }
+
    /// Assign a constant value
    pub fn assign_constant(&mut self, var: &VarTensor, value: F) -> Result<ValType<F>, Error> {
        self.total_constants += 1;
--- a/src/circuit/tests.rs
+++ b/src/circuit/tests.rs
@@ -2154,7 +2154,7 @@ mod rangecheckpercent {
        }

        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let scale = utils::F32(SCALE.pow(2) as f32);
+            let scale = utils::F32(SCALE as f32);
            let a = VarTensor::new_advice(cs, K, 1, LEN);
            let b = VarTensor::new_advice(cs, K, 1, LEN);
            let output = VarTensor::new_advice(cs, K, 1, LEN);
@@ -2162,11 +2162,12 @@ mod rangecheckpercent {
                Self::Config::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::SAFE);
            // set up a new GreaterThan and Recip tables
            let nl = &LookupOp::GreaterThan {
-                a: circuit::utils::F32((RANGE * scale.0) / 100.0),
+                a: circuit::utils::F32((RANGE * SCALE.pow(2) as f32) / 100.0),
            };
            config
                .configure_lookup(cs, &b, &output, &a, (-32768, 32768), K, nl)
                .unwrap();
+
            config
                .configure_lookup(
                    cs,
@@ -2175,7 +2176,10 @@ mod rangecheckpercent {
                    &a,
                    (-32768, 32768),
                    K,
-                    &LookupOp::Recip { scale },
+                    &LookupOp::Recip {
+                        input_scale: scale,
+                        output_scale: scale,
+                    },
                )
                .unwrap();
            config
@@ -2511,7 +2515,8 @@ mod softmax {
                    (-32768, 32768),
                    K,
                    &LookupOp::Recip {
-                        scale: SCALE.powf(2.0).into(),
+                        input_scale: SCALE.into(),
+                        output_scale: SCALE.into(),
                    },
                )
                .unwrap();
--- a/src/execute.rs
+++ b/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.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());
+            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);
        }

        let mean_percent_error =
--- a/src/graph/model.rs
+++ b/src/graph/model.rs
@@ -80,6 +80,21 @@ pub struct ModelConfig {
 /// Representation of execution graph
 pub type NodeGraph = BTreeMap<usize, NodeType>;

+/// A struct for loading from an Onnx file and converting a computational graph to a circuit.
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct DummyPassRes {
+    /// number of rows use
+    pub num_rows: usize,
+    /// linear coordinate
+    pub linear_coord: usize,
+    /// total const size
+    pub total_const_size: usize,
+    /// lookup ops
+    pub lookup_ops: HashSet<LookupOp>,
+    /// range checks
+    pub range_checks: HashSet<Range>,
+}
+
 /// A struct for loading from an Onnx file and converting a computational graph to a circuit.
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
 pub struct Model {
@@ -234,20 +249,7 @@ impl NodeType {
            NodeType::SubGraph { out_dims, .. } => out_dims.clone(),
        }
    }
-    /// Returns the lookups required by a graph
-    pub fn required_lookups(&self) -> Vec<LookupOp> {
-        match self {
-            NodeType::Node(n) => n.opkind.required_lookups(),
-            NodeType::SubGraph { model, .. } => model.required_lookups(),
-        }
-    }
-    /// Returns the lookups required by a graph
-    pub fn required_range_checks(&self) -> Vec<Range> {
-        match self {
-            NodeType::Node(n) => n.opkind.required_range_checks(),
-            NodeType::SubGraph { model, .. } => model.required_range_checks(),
-        }
-    }
+
    /// Returns the scales of the node's output.
    pub fn out_scales(&self) -> Vec<crate::Scale> {
        match self {
@@ -432,23 +434,6 @@ impl ParsedNodes {
 }

 impl Model {
-    fn required_lookups(&self) -> Vec<LookupOp> {
-        self.graph
-            .nodes
-            .values()
-            .flat_map(|n| n.required_lookups())
-            .collect_vec()
-    }
-
-    ///
-    fn required_range_checks(&self) -> Vec<Range> {
-        self.graph
-            .nodes
-            .values()
-            .flat_map(|n| n.required_range_checks())
-            .collect_vec()
-    }
-
    /// Creates a `Model` from a specified path to an Onnx file.
    /// # Arguments
    /// * `reader` - A reader for an Onnx file.
@@ -501,42 +486,21 @@ impl Model {
        );
        // this is the total number of variables we will need to allocate
        // for the circuit
-        let (num_rows, linear_coord, total_const_size) =
-            self.dummy_layout(run_args, &self.graph.input_shapes()?)?;
-
-        // extract the requisite lookup ops from the model
-        let mut lookup_ops: Vec<LookupOp> = self.required_lookups();
-        // extract the requisite lookup ops from the model
-        let mut range_checks: Vec<Range> = self.required_range_checks();
+        let res = self.dummy_layout(run_args, &self.graph.input_shapes()?)?;

        // if we're using percentage tolerance, we need to add the necessary range check ops for it.

-        if run_args.tolerance.val > 0.0 {
-            for scale in self.graph.get_output_scales()? {
-                let mut tolerance = run_args.tolerance;
-                tolerance.scale = scale_to_multiplier(scale).into();
-                let opkind: Box<dyn Op<Fp>> = Box::new(HybridOp::RangeCheck(tolerance));
-                lookup_ops.extend(opkind.required_lookups());
-            }
-        }
-
-        let set: HashSet<_> = lookup_ops.drain(..).collect(); // dedup
-        lookup_ops.extend(set.into_iter().sorted());
-
-        let set: HashSet<_> = range_checks.drain(..).collect(); // dedup
-        range_checks.extend(set.into_iter().sorted());
-
        Ok(GraphSettings {
            run_args: run_args.clone(),
            model_instance_shapes: instance_shapes,
            module_sizes: crate::graph::modules::ModuleSizes::default(),
-            num_rows,
-            total_assignments: linear_coord,
-            required_lookups: lookup_ops,
-            required_range_checks: range_checks,
+            num_rows: res.num_rows,
+            total_assignments: res.linear_coord,
+            required_lookups: res.lookup_ops.into_iter().collect(),
+            required_range_checks: res.range_checks.into_iter().collect(),
            model_output_scales: self.graph.get_output_scales()?,
            model_input_scales: self.graph.get_input_scales(),
-            total_const_size,
+            total_const_size: res.total_const_size,
            check_mode,
            version: env!("CARGO_PKG_VERSION").to_string(),
            num_blinding_factors: None,
@@ -1068,6 +1032,7 @@ impl Model {
                        i,
                        symbol_values,
                        run_args.div_rebasing,
+                        run_args.rebase_frac_zero_constants,
                    )?;
                    if let Some(ref scales) = override_input_scales {
                        if let Some(inp) = n.opkind.get_input() {
@@ -1208,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[1];
-        let index = &vars.advices[2];
+        let output = &vars.advices[2];
+        let index = &vars.advices[1];
        for op in required_lookups {
            base_gate.configure_lookup(meta, input, output, index, lookup_range, logrows, &op)?;
        }
@@ -1525,7 +1490,7 @@ impl Model {
        &self,
        run_args: &RunArgs,
        input_shapes: &[Vec<usize>],
-    ) -> Result<(usize, usize, usize), Box<dyn Error>> {
+    ) -> Result<DummyPassRes, Box<dyn Error>> {
        info!("calculating num of constraints using dummy model layout...");

        let start_time = instant::Instant::now();
@@ -1610,11 +1575,15 @@ impl Model {
            region.total_constants().to_string().red()
        );

-        Ok((
-            region.row(),
-            region.linear_coord(),
-            region.total_constants(),
-        ))
+        let res = DummyPassRes {
+            num_rows: region.row(),
+            linear_coord: region.linear_coord(),
+            total_const_size: region.total_constants(),
+            lookup_ops: region.used_lookups(),
+            range_checks: region.used_range_checks(),
+        };
+
+        Ok(res)
    }

    /// Retrieves all constants from the model.
--- a/src/graph/node.rs
+++ b/src/graph/node.rs
@@ -18,8 +18,6 @@ use crate::tensor::Tensor;
 use crate::tensor::TensorError;
 use halo2curves::bn256::Fr as Fp;
 #[cfg(not(target_arch = "wasm32"))]
-use itertools::Itertools;
-#[cfg(not(target_arch = "wasm32"))]
 use log::trace;
 use serde::Deserialize;
 use serde::Serialize;
@@ -92,10 +90,6 @@ impl Op<Fp> for Rescaled {
        Op::<Fp>::out_scale(&*self.inner, in_scales)
    }

-    fn required_lookups(&self) -> Vec<LookupOp> {
-        self.inner.required_lookups()
-    }
-
    fn layout(
        &self,
        config: &mut crate::circuit::BaseConfig<Fp>,
@@ -154,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,
@@ -244,18 +238,6 @@ impl Op<Fp> for RebaseScale {
        Ok(self.target_scale)
    }

-    fn required_lookups(&self) -> Vec<LookupOp> {
-        let mut lookups: Vec<LookupOp> = self.inner.required_lookups();
-        lookups.extend(Op::<Fp>::required_lookups(&self.rebase_op));
-        lookups
-    }
-
-    fn required_range_checks(&self) -> Vec<crate::circuit::table::Range> {
-        let mut range_checks = self.inner.required_range_checks();
-        range_checks.extend(Op::<Fp>::required_range_checks(&self.rebase_op));
-        range_checks
-    }
-
    fn layout(
        &self,
        config: &mut crate::circuit::BaseConfig<Fp>,
@@ -449,14 +431,6 @@ impl Op<Fp> for SupportedOp {
        self
    }

-    fn required_lookups(&self) -> Vec<LookupOp> {
-        self.as_op().required_lookups()
-    }
-
-    fn required_range_checks(&self) -> Vec<crate::circuit::table::Range> {
-        self.as_op().required_range_checks()
-    }
-
    fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
        self.as_op().out_scale(in_scales)
    }
@@ -490,15 +464,7 @@ impl Tabled for Node {

    fn headers() -> Vec<std::borrow::Cow<'static, str>> {
        let mut headers = Vec::with_capacity(Self::LENGTH);
-        for i in [
-            "idx",
-            "opkind",
-            "out_scale",
-            "inputs",
-            "out_dims",
-            "required_lookups",
-            "required_range_checks",
-        ] {
+        for i in ["idx", "opkind", "out_scale", "inputs", "out_dims"] {
            headers.push(std::borrow::Cow::Borrowed(i));
        }
        headers
@@ -511,18 +477,6 @@ impl Tabled for Node {
        fields.push(std::borrow::Cow::Owned(self.out_scale.to_string()));
        fields.push(std::borrow::Cow::Owned(display_vector(&self.inputs)));
        fields.push(std::borrow::Cow::Owned(display_vector(&self.out_dims)));
-        fields.push(std::borrow::Cow::Owned(format!(
-            "{:?}",
-            self.opkind
-                .required_lookups()
-                .iter()
-                .map(<LookupOp as Op<Fp>>::as_string)
-                .collect_vec()
-        )));
-        fields.push(std::borrow::Cow::Owned(format!(
-            "{:?}",
-            self.opkind.required_range_checks()
-        )));
        fields
    }
 }
@@ -553,6 +507,7 @@ impl Node {
        idx: usize,
        symbol_values: &SymbolValues,
        div_rebasing: bool,
+        rebase_frac_zero_constants: bool,
    ) -> Result<Self, Box<dyn Error>> {
        trace!("Create {:?}", node);
        trace!("Create op {:?}", node.op);
@@ -591,6 +546,7 @@ impl Node {
            node.clone(),
            &mut inputs,
            symbol_values,
+            rebase_frac_zero_constants,
        )?; // parses the op name

        // we can only take the inputs as mutable once -- so we need to collect them first
--- a/src/graph/utilities.rs
+++ b/src/graph/utilities.rs
@@ -243,6 +243,7 @@ pub fn new_op_from_onnx(
    node: OnnxNode<TypedFact, Box<dyn TypedOp>>,
    inputs: &mut [super::NodeType],
    symbol_values: &SymbolValues,
+    rebase_frac_zero_constants: bool,
 ) -> Result<(SupportedOp, Vec<usize>), Box<dyn std::error::Error>> {
    use crate::circuit::InputType;

@@ -546,7 +547,7 @@ pub fn new_op_from_onnx(
            // Raw values are always f32
            let raw_value = extract_tensor_value(op.0)?;
            // If bool or a tensor dimension then don't scale
-            let constant_scale = match dt {
+            let mut constant_scale = match dt {
                DatumType::Bool
                | DatumType::TDim
                | DatumType::I64
@@ -562,6 +563,10 @@ pub fn new_op_from_onnx(
            };

            // if all raw_values are round then set scale to 0
+            let all_round = raw_value.iter().all(|x| (x).fract() == 0.0);
+            if all_round && rebase_frac_zero_constants {
+                constant_scale = 0;
+            }

            // Quantize the raw value
            let quantized_value =
@@ -726,16 +731,12 @@ pub fn new_op_from_onnx(
        }
        "Recip" => {
            let in_scale = inputs[0].out_scales()[0];
+            let max_scale = std::cmp::max(scales.get_max(), in_scale);
            // If the input scale is larger than the params scale
-            let scale_diff = scales.get_max() - inputs[0].out_scales()[0];
-            let additional_scale = if scale_diff > 0 {
-                scale_to_multiplier(scale_diff)
-            } else {
-                1.0
-            };
-
-            SupportedOp::Nonlinear(LookupOp::Recip {
-                scale: (scale_to_multiplier(in_scale).powf(2.0) * additional_scale).into(),
+            SupportedOp::Hybrid(HybridOp::Recip {
+                input_scale: (scale_to_multiplier(in_scale) as f32).into(),
+                output_scale: (scale_to_multiplier(max_scale) as f32).into(),
+                use_range_check_for_int: false,
            })
        }

--- a/src/lib.rs
+++ b/src/lib.rs
@@ -111,8 +111,11 @@ pub struct RunArgs {
    #[arg(long, default_value = "private")]
    pub param_visibility: Visibility,
    #[arg(long, default_value = "false")]
-    /// Multiplicative division
+    /// Rebase the scale using lookup table for division instead of using a range check
    pub div_rebasing: bool,
+    /// Should constants with 0.0 fraction be rebased to scale 0
+    #[arg(long, default_value = "false")]
+    pub rebase_frac_zero_constants: bool,
    /// check mode (safe, unsafe, etc)
    #[arg(long, default_value = "unsafe")]
    pub check_mode: CheckMode,
@@ -133,6 +136,7 @@ impl Default for RunArgs {
            output_visibility: Visibility::Public,
            param_visibility: Visibility::Private,
            div_rebasing: false,
+            rebase_frac_zero_constants: false,
            check_mode: CheckMode::UNSAFE,
        }
    }
--- a/src/python.rs
+++ b/src/python.rs
@@ -162,6 +162,8 @@ struct PyRunArgs {
    #[pyo3(get, set)]
    pub div_rebasing: bool,
    #[pyo3(get, set)]
+    pub rebase_frac_zero_constants: bool,
+    #[pyo3(get, set)]
    pub check_mode: CheckMode,
 }

@@ -190,6 +192,7 @@ impl From<PyRunArgs> for RunArgs {
            param_visibility: py_run_args.param_visibility,
            variables: py_run_args.variables,
            div_rebasing: py_run_args.div_rebasing,
+            rebase_frac_zero_constants: py_run_args.rebase_frac_zero_constants,
            check_mode: py_run_args.check_mode,
        }
    }
@@ -210,6 +213,7 @@ impl Into<PyRunArgs> for RunArgs {
            param_visibility: self.param_visibility,
            variables: self.variables,
            div_rebasing: self.div_rebasing,
+            rebase_frac_zero_constants: self.rebase_frac_zero_constants,
            check_mode: self.check_mode,
        }
    }
--- a/src/tensor/ops.rs
+++ b/src/tensor/ops.rs
@@ -992,45 +992,6 @@ pub fn mult<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::S
    Ok(output)
 }

-/// Divides multiple tensors.
-/// # Arguments
-/// * `t` - Tensors
-/// # Examples
-/// ```
-/// use ezkl::tensor::Tensor;
-/// use ezkl::tensor::ops::div;
-/// let x = Tensor::<i128>::new(
-///    Some(&[2, 1, 2, 1, 1, 1]),
-/// &[2, 3],
-/// ).unwrap();
-/// let k = Tensor::<i128>::new(
-///   Some(&[2, 3, 2, 1, 1, 1]),
-/// &[2, 3],
-/// ).unwrap();
-/// let result = div(&[x, k]).unwrap();
-/// let expected = Tensor::<i128>::new(Some(&[1, 0, 1, 1, 1, 1]), &[2, 3]).unwrap();
-/// assert_eq!(result, expected);
-/// ```
-pub fn div<
-    T: TensorType
-        + Div<Output = T>
-        + Mul<Output = T>
-        + From<u64>
-        + std::marker::Send
-        + std::marker::Sync,
->(
-    t: &[Tensor<T>],
-) -> Result<Tensor<T>, TensorError> {
-    // calculate value of output
-    let mut output: Tensor<T> = t[0].clone();
-
-    for e in t[1..].iter() {
-        output = (output / e.clone())?;
-    }
-
-    Ok(output)
-}
-
 /// Rescale a tensor with a const integer (similar to const_mult).
 /// # Arguments
 ///
@@ -3164,7 +3125,7 @@ pub mod nonlinearities {

        let sum = sum(&exp).unwrap();
        intermediate_values.push(sum.clone());
-        let inv_denom = recip(&sum, scale.powf(2.0));
+        let inv_denom = recip(&sum, scale, scale);

        ((exp * inv_denom).unwrap(), intermediate_values)
    }
@@ -3201,7 +3162,7 @@ pub mod nonlinearities {
        // the more accurate calculation is commented out and we implement as below so it matches the steps in layout
        let scale = input_scale * output_scale;
        let diff: Tensor<i128> = sub(t).unwrap();
-        let recip = recip(&t[0], scale as f64);
+        let recip = recip(&t[0], input_scale as f64, output_scale as f64);
        let product = mult(&[diff, recip]).unwrap();
        let _tol = ((tol / 100.0) * scale as f32).round() as f64;
        let upper_bound = greater_than(&product, _tol);
@@ -3812,14 +3773,15 @@ pub mod nonlinearities {
    ///     &[2, 3],
    /// ).unwrap();
    /// let k = 2_f64;
-    /// let result = recip(&x, k);
+    /// let result = recip(&x, 1.0, k);
    /// let expected = Tensor::<i128>::new(Some(&[1, 2, 1, 0, 2, 2]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    /// ```
-    pub fn recip(a: &Tensor<i128>, scale: f64) -> Tensor<i128> {
+    pub fn recip(a: &Tensor<i128>, input_scale: f64, out_scale: f64) -> Tensor<i128> {
        a.par_enum_map(|_, a_i| {
-            let denom = (1_f64) / (a_i as f64 + f64::EPSILON);
-            let d_inv_x = scale * denom;
+            let rescaled = (a_i as f64) / input_scale;
+            let denom = (1_f64) / (rescaled + f64::EPSILON);
+            let d_inv_x = out_scale * denom;
            Ok::<_, TensorError>(d_inv_x.round() as i128)
        })
        .unwrap()
--- a/src/tensor/val.rs
+++ b/src/tensor/val.rs
@@ -871,3 +871,30 @@ 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)
+    }
+}
--- a/tests/integration_tests.rs
+++ b/tests/integration_tests.rs
@@ -192,86 +192,86 @@ mod native_tests {
    ];

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

--- a/tests/wasm/model.compiled
+++ b/tests/wasm/model.compiled
--- a/tests/wasm/settings.json
+++ b/tests/wasm/settings.json
@@ -23,6 +23,7 @@
        "output_visibility": "Public",
        "param_visibility": "Private",
        "div_rebasing": false,
+        "rebase_frac_zero_constants": false,
        "check_mode": "UNSAFE"
    },
    "num_rows": 16,
Author	SHA1	Message	Date
dante	80041ac523	refactor: equals argument without lookups (#705 )	2024-02-07 14:20:13 +00:00
dante	2a1ee1102c	refactor: range check recip (#703 )	2024-02-05 14:42:26 +00:00