fix: include tol check in fwd pass (#723)

.github/workflows/rust.yml

@@ -236,6 +236,8 @@ jobs:
         with:
           crate: cargo-nextest
           locked: true
+      - name: public outputs and tolerance > 0
+        run: cargo nextest run --release --verbose tests::mock_tolerance_public_outputs_ --test-threads 32
       - name: public outputs + batch size == 10
         run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 32
       - name: kzg inputs

src/circuit/ops/layouts.rs

@@ -2953,8 +2953,17 @@ pub fn range_check_percent<F: PrimeField + TensorType + PartialOrd>(
         return enforce_equality(config, region, values);
     }
 
+    let mut values = [values[0].clone(), values[1].clone()];
+
+    values[0] = region.assign(&config.inputs[0], &values[0])?;
+    values[1] = region.assign(&config.inputs[1], &values[1])?;
+    let total_assigned_0 = values[0].len();
+    let total_assigned_1 = values[1].len();
+    let total_assigned = std::cmp::max(total_assigned_0, total_assigned_1);
+    region.increment(total_assigned);
+
     // Calculate the difference between the expected output and actual output
-    let diff = pairwise(config, region, values, BaseOp::Sub)?;
+    let diff = pairwise(config, region, &values, BaseOp::Sub)?;
 
     // Calculate the reciprocal of the expected output tensor, scaling by double the scaling factor
     let recip = nonlinearity(

src/circuit/ops/lookup.rs

@@ -243,10 +243,10 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
             LookupOp::Max { scale, a } => format!("MAX(scale={}, a={})", scale, a),
             LookupOp::Min { scale, a } => format!("MIN(scale={}, a={})", scale, a),
             LookupOp::Sign => "SIGN".into(),
-            LookupOp::GreaterThan { .. } => "GREATER_THAN".into(),
-            LookupOp::GreaterThanEqual { .. } => "GREATER_THAN_EQUAL".into(),
-            LookupOp::LessThan { .. } => "LESS_THAN".into(),
-            LookupOp::LessThanEqual { .. } => "LESS_THAN_EQUAL".into(),
+            LookupOp::GreaterThan { a } => format!("GREATER_THAN(a={})", a),
+            LookupOp::GreaterThanEqual { a } => format!("GREATER_THAN_EQUAL(a={})", a),
+            LookupOp::LessThan { a } => format!("LESS_THAN(a={})", a),
+            LookupOp::LessThanEqual { a } => format!("LESS_THAN_EQUAL(a={})", a),
             LookupOp::Recip {
                 input_scale,
                 output_scale,

src/commands.rs

@@ -88,6 +88,8 @@ pub const DEFAULT_VK_ABI: &str = "vk.abi";
 pub const DEFAULT_SCALE_REBASE_MULTIPLIERS: &str = "1,2,10";
 /// Default use reduced srs for verification
 pub const DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION: &str = "false";
+/// Default only check for range check rebase
+pub const DEFAULT_ONLY_RANGE_CHECK_REBASE: &str = "false";
 
 #[cfg(feature = "python-bindings")]
 /// Converts TranscriptType into a PyObject (Required for TranscriptType to be compatible with Python)
@@ -371,9 +373,9 @@ pub enum Commands {
         /// max logrows to use for calibration, 26 is the max public SRS size
         #[arg(long)]
         max_logrows: Option<u32>,
-        // whether to fix the div_rebasing value truthiness during calibration. this changes how we rebase
-        #[arg(long)]
-        div_rebasing: Option<bool>,
+        // whether to only range check rebases (instead of trying both range check and lookup)
+        #[arg(long, default_value = DEFAULT_ONLY_RANGE_CHECK_REBASE)]
+        only_range_check_rebase: bool,
     },
 
     /// Generates a dummy SRS
@@ -732,7 +734,7 @@ pub enum Commands {
         srs_path: Option<PathBuf>,
         /// Reduce SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
         #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION)]
-        reduced_srs: Option<bool>,
+        reduced_srs: bool,
     },
     /// Verifies an aggregate proof, returning accept or reject
     VerifyAggr {

src/execute.rs

@@ -178,7 +178,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             scales,
             scale_rebase_multiplier,
             max_logrows,
-            div_rebasing,
+            only_range_check_rebase,
         } => calibrate(
             model,
             data,
@@ -187,7 +187,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             lookup_safety_margin,
             scales,
             scale_rebase_multiplier,
-            div_rebasing,
+            only_range_check_rebase,
             max_logrows,
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
@@ -789,7 +789,7 @@ pub(crate) fn calibrate(
     lookup_safety_margin: i128,
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
-    div_rebasing: Option<bool>,
+    only_range_check_rebase: bool,
     max_logrows: Option<u32>,
 ) -> Result<GraphSettings, Box<dyn Error>> {
     use std::collections::HashMap;
@@ -830,8 +830,8 @@ pub(crate) fn calibrate(
         (10..14).collect::<Vec<crate::Scale>>()
     };
 
-    let div_rebasing = if let Some(div_rebasing) = div_rebasing {
-        vec![div_rebasing]
+    let div_rebasing = if only_range_check_rebase {
+        vec![false]
     } else {
         vec![true, false]
     };
@@ -2044,16 +2044,12 @@ pub(crate) fn verify(
     settings_path: PathBuf,
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
-    reduced_srs: Option<bool>,
+    reduced_srs: bool,
 ) -> Result<bool, Box<dyn Error>> {
     let circuit_settings = GraphSettings::load(&settings_path)?;
 
-    let params = if let Some(reduced_srs) = reduced_srs {
-        if reduced_srs {
-            load_params_cmd(srs_path, circuit_settings.log2_total_instances())?
-        } else {
-            load_params_cmd(srs_path, circuit_settings.run_args.logrows)?
-        }
+    let params = if reduced_srs {
+        load_params_cmd(srs_path, circuit_settings.log2_total_instances())?
     } else {
         load_params_cmd(srs_path, circuit_settings.run_args.logrows)?
     };

src/graph/mod.rs

@@ -1248,7 +1248,7 @@ impl GraphCircuit {
             }
         }
 
-        let mut model_results = self.model().forward(inputs)?;
+        let mut model_results = self.model().forward(inputs, &self.settings().run_args)?;
 
         if visibility.output.requires_processing() {
             let module_outlets = visibility.output.overwrites_inputs();

src/graph/model.rs

@@ -556,12 +556,16 @@ impl Model {
     /// * `reader` - A reader for an Onnx file.
     /// * `model_inputs` - A vector of [Tensor]s to use as inputs to the model.
     /// * `run_args` - [RunArgs]
-    pub fn forward(&self, model_inputs: &[Tensor<Fp>]) -> Result<ForwardResult, Box<dyn Error>> {
+    pub fn forward(
+        &self,
+        model_inputs: &[Tensor<Fp>],
+        run_args: &RunArgs,
+    ) -> Result<ForwardResult, Box<dyn Error>> {
         let valtensor_inputs: Vec<ValTensor<Fp>> = model_inputs
             .iter()
             .map(|x| x.map(|elem| ValType::Value(Value::known(elem))).into())
             .collect();
-        let res = self.dummy_layout(&RunArgs::default(), &valtensor_inputs)?;
+        let res = self.dummy_layout(&run_args, &valtensor_inputs)?;
         Ok(res.into())
     }
 
@@ -1371,27 +1375,26 @@ impl Model {
                 ValType::Constant(Fp::ONE)
             };
 
-            let comparator = outputs
+            let output_scales = self.graph.get_output_scales()?;
+            let res = outputs
                 .iter()
-                .map(|x| {
-                    let mut v: ValTensor<Fp> =
-                        vec![default_value.clone(); x.dims().iter().product::<usize>()].into();
-                    v.reshape(x.dims())?;
-                    Ok(v)
-                })
-                .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
+                .enumerate()
+                .map(|(i, output)| {
+                    let mut tolerance = run_args.tolerance;
+                    tolerance.scale = scale_to_multiplier(output_scales[i]).into();
+
+                    let mut comparator: ValTensor<Fp> =
+                        vec![default_value.clone(); output.dims().iter().product::<usize>()].into();
+                    comparator.reshape(output.dims())?;
 
-            let _ = outputs
-                .iter()
-                .zip(comparator)
-                .map(|(o, c)| {
                     dummy_config.layout(
                         &mut region,
-                        &[o.clone(), c],
-                        Box::new(HybridOp::RangeCheck(run_args.tolerance)),
+                        &[output.clone(), comparator],
+                        Box::new(HybridOp::RangeCheck(tolerance)),
                     )
                 })
-                .collect::<Result<Vec<_>, _>>()?;
+                .collect::<Result<Vec<_>, _>>();
+            res?;
         } else if !self.visibility.output.is_private() {
             for output in &outputs {
                 region.increment_total_constants(output.num_constants());

src/pfsys/mod.rs

@@ -728,12 +728,13 @@ where
     let f =
         File::open(path.clone()).map_err(|_| format!("failed to load vk at {}", path.display()))?;
     let mut reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, f);
-    VerifyingKey::<Scheme::Curve>::read::<_, C>(
+    let vk = VerifyingKey::<Scheme::Curve>::read::<_, C>(
         &mut reader,
         serde_format_from_str(&EZKL_KEY_FORMAT),
         params,
-    )
-    .map_err(Box::<dyn Error>::from)
+    )?;
+    info!("done loading verification key ✅");
+    Ok(vk)
 }
 
 /// Loads a [ProvingKey] at `path`.
@@ -750,12 +751,13 @@ where
     let f =
         File::open(path.clone()).map_err(|_| format!("failed to load pk at {}", path.display()))?;
     let mut reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, f);
-    ProvingKey::<Scheme::Curve>::read::<_, C>(
+    let pk = ProvingKey::<Scheme::Curve>::read::<_, C>(
         &mut reader,
         serde_format_from_str(&EZKL_KEY_FORMAT),
         params,
-    )
-    .map_err(Box::<dyn Error>::from)
+    )?;
+    info!("done loading proving key ✅");
+    Ok(pk)
 }
 
 /// Saves a [ProvingKey] to `path`.
@@ -772,6 +774,7 @@ where
     let mut writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
     pk.write(&mut writer, serde_format_from_str(&EZKL_KEY_FORMAT))?;
     writer.flush()?;
+    info!("done saving proving key ✅");
     Ok(())
 }
 
@@ -789,6 +792,7 @@ where
     let mut writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
     vk.write(&mut writer, serde_format_from_str(&EZKL_KEY_FORMAT))?;
     writer.flush()?;
+    info!("done saving verification key ✅");
     Ok(())
 }
 

src/python.rs

@@ -523,7 +523,7 @@ fn gen_settings(
     scales = None,
     scale_rebase_multiplier = DEFAULT_SCALE_REBASE_MULTIPLIERS.split(",").map(|x| x.parse().unwrap()).collect(),
     max_logrows = None,
-    div_rebasing = None,
+    only_range_check_rebase = DEFAULT_ONLY_RANGE_CHECK_REBASE.parse().unwrap(),
 ))]
 fn calibrate_settings(
     data: PathBuf,
@@ -534,7 +534,7 @@ fn calibrate_settings(
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
     max_logrows: Option<u32>,
-    div_rebasing: Option<bool>,
+    only_range_check_rebase: bool,
 ) -> Result<bool, PyErr> {
     crate::execute::calibrate(
         model,
@@ -544,7 +544,7 @@ fn calibrate_settings(
         lookup_safety_margin,
         scales,
         scale_rebase_multiplier,
-        div_rebasing,
+        only_range_check_rebase,
         max_logrows,
     )
     .map_err(|e| {
@@ -687,14 +687,14 @@ fn prove(
     settings_path=PathBuf::from(DEFAULT_SETTINGS),
     vk_path=PathBuf::from(DEFAULT_VK),
     srs_path=None,
-    non_reduced_srs=Some(DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse::<bool>().unwrap()),
+    non_reduced_srs=DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse::<bool>().unwrap(),
 ))]
 fn verify(
     proof_path: PathBuf,
     settings_path: PathBuf,
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
-    non_reduced_srs: Option<bool>,
+    non_reduced_srs: bool,
 ) -> Result<bool, PyErr> {
     crate::execute::verify(
         proof_path,

src/tensor/val.rs

@@ -672,7 +672,7 @@ impl<F: PrimeField + TensorType + PartialOrd> ValTensor<F> {
                 }
                 Ok(indices)
             }
-            ValTensor::Instance { .. } => Err(TensorError::WrongMethod),
+            ValTensor::Instance { .. } => Ok(vec![]),
         }
     }
 
@@ -690,7 +690,7 @@ impl<F: PrimeField + TensorType + PartialOrd> ValTensor<F> {
                 }
                 Ok(indices)
             }
-            ValTensor::Instance { .. } => Err(TensorError::WrongMethod),
+            ValTensor::Instance { .. } => Ok(vec![]),
         }
     }
 
@@ -709,7 +709,11 @@ impl<F: PrimeField + TensorType + PartialOrd> ValTensor<F> {
                 *d = v.dims().to_vec();
             }
             ValTensor::Instance { .. } => {
-                return Err(TensorError::WrongMethod);
+                if indices.is_empty() {
+                    return Ok(());
+                } else {
+                    return Err(TensorError::WrongMethod);
+                }
             }
         }
         Ok(())

tests/integration_tests.rs

@@ -477,6 +477,7 @@ mod native_tests {
             use crate::native_tests::kzg_fuzz;
             use crate::native_tests::render_circuit;
             use crate::native_tests::model_serialization_different_binaries;
+            use rand::Rng;
             use tempdir::TempDir;
 
             #[test]
@@ -496,7 +497,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "fixed", "public", 1, "accuracy", None);
+                mock(path, test.to_string(), "public", "fixed", "public", 1, "accuracy", None, 0.0);
                 test_dir.close().unwrap();
             }
         });
@@ -569,7 +570,18 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None);
+                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, 0.0);
+                test_dir.close().unwrap();
+            }
+
+            #(#[test_case(TESTS[N])])*
+            fn mock_tolerance_public_outputs_(test: &str) {
+                crate::native_tests::init_binary();
+                let test_dir = TempDir::new(test).unwrap();
+                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                // gen random number between 0.0 and 1.0
+                let tolerance = rand::thread_rng().gen_range(0.0..1.0) * 100.0;
+                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, tolerance);
                 test_dir.close().unwrap();
             }
 
@@ -580,7 +592,7 @@ mod native_tests {
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                 let large_batch_dir = &format!("large_batches_{}", test);
                 crate::native_tests::mk_data_batches_(path, test, &large_batch_dir, 10);
-                mock(path, large_batch_dir.to_string(), "private", "private", "public", 10, "resources", None);
+                mock(path, large_batch_dir.to_string(), "private", "private", "public", 10, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -589,7 +601,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "private", "private", 1, "resources", None);
+                mock(path, test.to_string(), "public", "private", "private", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -598,7 +610,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "fixed", "private", "private", 1, "resources", None);
+                mock(path, test.to_string(), "fixed", "private", "private", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -607,7 +619,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "private", "fixed", 1, "resources", None);
+                mock(path, test.to_string(), "private", "private", "fixed", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -616,7 +628,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "fixed", "private", 1, "resources", None);
+                mock(path, test.to_string(), "private", "fixed", "private", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -625,7 +637,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "hashed", "private", "public", 1, "resources", None);
+                mock(path, test.to_string(), "hashed", "private", "public", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -634,7 +646,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "kzgcommit", "private", "public", 1, "resources", None);
+                mock(path, test.to_string(), "kzgcommit", "private", "public", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -644,7 +656,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "hashed", "public", 1, "resources", None);
+                mock(path, test.to_string(), "private", "hashed", "public", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -654,7 +666,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "kzgcommit", "public", 1, "resources", None);
+                mock(path, test.to_string(), "private", "kzgcommit", "public", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -663,7 +675,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "private", "hashed", 1, "resources", None);
+                mock(path, test.to_string(), "public", "private", "hashed", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -673,7 +685,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "private", "kzgcommit", 1, "resources", None);
+                mock(path, test.to_string(), "public", "private", "kzgcommit", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -682,7 +694,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "fixed", "hashed", 1, "resources", None);
+                mock(path, test.to_string(), "public", "fixed", "hashed", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -692,7 +704,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "kzgcommit", "hashed", 1, "resources", None);
+                mock(path, test.to_string(), "public", "kzgcommit", "hashed", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -702,7 +714,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "kzgcommit", "kzgcommit", "kzgcommit", 1, "resources", None);
+                mock(path, test.to_string(), "kzgcommit", "kzgcommit", "kzgcommit", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -712,7 +724,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "hashed", "private", "hashed", 1, "resources", None);
+                mock(path, test.to_string(), "hashed", "private", "hashed", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -722,7 +734,7 @@ mod native_tests {
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                 // needs an extra row for the large model
-                mock(path, test.to_string(),"hashed", "hashed", "public", 1, "resources", None);
+                mock(path, test.to_string(),"hashed", "hashed", "public", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -732,7 +744,7 @@ mod native_tests {
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                 // needs an extra row for the large model
-                mock(path, test.to_string(),"hashed", "hashed", "hashed", 1, "resources", None);
+                mock(path, test.to_string(),"hashed", "hashed", "hashed", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
 
@@ -876,7 +888,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "fixed", "public", 1, "resources", None);
+                mock(path, test.to_string(), "private", "fixed", "public", 1, "resources", None, 0.0);
                 test_dir.close().unwrap();
             }
         });
@@ -1273,6 +1285,7 @@ mod native_tests {
         batch_size: usize,
         cal_target: &str,
         scales_to_use: Option<Vec<u32>>,
+        tolerance: f32,
     ) {
         gen_circuit_settings_and_witness(
             test_dir,
@@ -1285,6 +1298,7 @@ mod native_tests {
             scales_to_use,
             2,
             false,
+            tolerance,
         );
 
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
@@ -1312,6 +1326,7 @@ mod native_tests {
         scales_to_use: Option<Vec<u32>>,
         num_inner_columns: usize,
         div_rebasing: bool,
+        tolerance: f32,
     ) {
         let mut args = vec![
             "gen-settings".to_string(),
@@ -1326,6 +1341,7 @@ mod native_tests {
             format!("--param-visibility={}", param_visibility),
             format!("--output-visibility={}", output_visibility),
             format!("--num-inner-cols={}", num_inner_columns),
+            format!("--tolerance={}", tolerance),
         ];
 
         if div_rebasing {
@@ -1425,6 +1441,7 @@ mod native_tests {
             None,
             2,
             div_rebasing,
+            0.0,
         );
 
         println!(
@@ -1684,6 +1701,7 @@ mod native_tests {
             scales_to_use,
             num_inner_columns,
             false,
+            0.0,
         );
 
         let settings_path = format!("{}/{}/settings.json", test_dir, example_name);
@@ -1765,7 +1783,7 @@ mod native_tests {
                 &format!("{}/{}/proof.pf", test_dir, example_name),
                 "--vk-path",
                 &format!("{}/{}/key.vk", test_dir, example_name),
-                "--reduced-srs=true",
+                "--reduced-srs",
             ])
             .status()
             .expect("failed to execute process");
@@ -1785,6 +1803,7 @@ mod native_tests {
             None,
             2,
             false,
+            0.0,
         );
 
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
@@ -2061,6 +2080,7 @@ mod native_tests {
             Some(vec![4]),
             1,
             false,
+            0.0,
         );
 
         let model_path = format!("{}/{}/network.compiled", test_dir, example_name);