fix: uncomparable values in acc table (#701)

.github/workflows/rust.yml

@@ -427,21 +427,21 @@ jobs:
           crate: cargo-nextest
           locked: true
       - name: KZG prove and verify tests (kzg outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
       - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
       - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
       - name: KZG prove and verify tests (public outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
       - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
       - name: KZG prove and verify tests (public inputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
       - name: KZG prove and verify tests (fixed params)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
       - name: KZG prove and verify tests (hashed outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1
 
   fuzz-tests:
     runs-on: ubuntu-latest-32-cores

src/commands.rs

@@ -336,6 +336,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>,
     },
 
     /// Generates a dummy SRS

src/execute.rs

@@ -178,6 +178,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             scales,
             scale_rebase_multiplier,
             max_logrows,
+            div_rebasing,
         } => calibrate(
             model,
             data,
@@ -186,6 +187,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             lookup_safety_margin,
             scales,
             scale_rebase_multiplier,
+            div_rebasing,
             max_logrows,
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
@@ -735,22 +737,22 @@ impl AccuracyResults {
         let median_error = errors[errors.len() / 2];
         let max_error = *errors
             .iter()
-            .max_by(|a, b| a.partial_cmp(b).unwrap())
+            .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
             .unwrap();
         let min_error = *errors
             .iter()
-            .min_by(|a, b| a.partial_cmp(b).unwrap())
+            .min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
             .unwrap();
 
         let mean_abs_error = abs_errors.iter().sum::<f32>() / abs_errors.len() as f32;
         let median_abs_error = abs_errors[abs_errors.len() / 2];
         let max_abs_error = *abs_errors
             .iter()
-            .max_by(|a, b| a.partial_cmp(b).unwrap())
+            .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
             .unwrap();
         let min_abs_error = *abs_errors
             .iter()
-            .min_by(|a, b| a.partial_cmp(b).unwrap())
+            .min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
             .unwrap();
 
         let mean_squared_error = squared_errors.iter().sum::<f32>() / squared_errors.len() as f32;
@@ -782,6 +784,7 @@ pub(crate) fn calibrate(
     lookup_safety_margin: i128,
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
+    div_rebasing: Option<bool>,
     max_logrows: Option<u32>,
 ) -> Result<GraphSettings, Box<dyn Error>> {
     use std::collections::HashMap;
@@ -825,6 +828,12 @@ pub(crate) fn calibrate(
         }
     };
 
+    let div_rebasing = if let Some(div_rebasing) = div_rebasing {
+        vec![div_rebasing]
+    } else {
+        vec![true, false]
+    };
+
     let mut found_params: Vec<GraphSettings> = vec![];
 
     // 2 x 2 grid
@@ -862,15 +871,21 @@ pub(crate) fn calibrate(
         .map(|(a, b)| (*a, *b))
         .collect::<Vec<((crate::Scale, crate::Scale), u32)>>();
 
+    let range_grid = range_grid
+        .iter()
+        .cartesian_product(div_rebasing.iter())
+        .map(|(a, b)| (*a, *b))
+        .collect::<Vec<(((crate::Scale, crate::Scale), u32), bool)>>();
+
     let mut forward_pass_res = HashMap::new();
 
     let pb = init_bar(range_grid.len() as u64);
     pb.set_message("calibrating...");
 
-    for ((input_scale, param_scale), scale_rebase_multiplier) in range_grid {
+    for (((input_scale, param_scale), scale_rebase_multiplier), div_rebasing) in range_grid {
         pb.set_message(format!(
-            "input scale: {}, param scale: {}, scale rebase multiplier: {}",
-            input_scale, param_scale, scale_rebase_multiplier
+            "input scale: {}, param scale: {}, scale rebase multiplier: {}, div rebasing: {}",
+            input_scale, param_scale, scale_rebase_multiplier, div_rebasing
         ));
 
         #[cfg(unix)]
@@ -890,6 +905,7 @@ pub(crate) fn calibrate(
             input_scale,
             param_scale,
             scale_rebase_multiplier,
+            div_rebasing,
             ..settings.run_args.clone()
         };
 
@@ -964,6 +980,7 @@ pub(crate) fn calibrate(
             let found_run_args = RunArgs {
                 input_scale: new_settings.run_args.input_scale,
                 param_scale: new_settings.run_args.param_scale,
+                div_rebasing: new_settings.run_args.div_rebasing,
                 lookup_range: new_settings.run_args.lookup_range,
                 logrows: new_settings.run_args.logrows,
                 scale_rebase_multiplier: new_settings.run_args.scale_rebase_multiplier,

src/python.rs

@@ -521,6 +521,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,
 ))]
 fn calibrate_settings(
     data: PathBuf,
@@ -531,6 +532,7 @@ fn calibrate_settings(
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
     max_logrows: Option<u32>,
+    div_rebasing: Option<bool>,
 ) -> Result<bool, PyErr> {
     crate::execute::calibrate(
         model,
@@ -540,6 +542,7 @@ fn calibrate_settings(
         lookup_safety_margin,
         scales,
         scale_rebase_multiplier,
+        div_rebasing,
         max_logrows,
     )
     .map_err(|e| {

tests/integration_tests.rs

@@ -836,10 +836,10 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     env_logger::init();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    kzg_prove_and_verify(path, test.to_string(), "safe", "private", "private", "public", 1, Some(vec![0,1]), true, "single");
+                    kzg_prove_and_verify(path, test.to_string(), "safe", "private", "private", "public", 1, None, true, "single");
                     #[cfg(not(feature = "icicle"))]
                     run_js_tests(path, test.to_string(), "testWasm");
-                    test_dir.close().unwrap();
+                    // test_dir.close().unwrap();
                 }
 
                 #(#[test_case(WASM_TESTS[N])])*
@@ -849,7 +849,7 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     env_logger::init();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    kzg_prove_and_verify(path, test.to_string(), "safe", "private", "fixed", "public", 1, Some(vec![0,1]), true, "single");
+                    kzg_prove_and_verify(path, test.to_string(), "safe", "private", "fixed", "public", 1, None, true, "single");
                     #[cfg(not(feature = "icicle"))]
                     run_js_tests(path, test.to_string(), "testWasm");
                     test_dir.close().unwrap();
@@ -865,7 +865,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);
-                kzg_prove_and_verify(path, test.to_string(), "unsafe", "private", "fixed", "public", 1, Some(vec![0,6]), false, "single");
+                kzg_prove_and_verify(path, test.to_string(), "unsafe", "private", "fixed", "public", 1, None, false, "single");
                 test_dir.close().unwrap();
             }
 
@@ -875,7 +875,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", Some(vec![0,6]));
+                mock(path, test.to_string(), "private", "fixed", "public", 1, "resources", None);
                 test_dir.close().unwrap();
             }
         });