Arnab/swiper

fastcrypto-tbls/Cargo.toml

@@ -10,6 +10,7 @@ repository = "https://github.com/MystenLabs/fastcrypto"
 
 [dependencies]
 fastcrypto = { path = "../fastcrypto", features = ["aes"] }
+num-rational = { version = "0.4.2", features = ["std"] }
 
 rand.workspace = true
 serde.workspace = true
@@ -28,6 +29,7 @@ serde-big-array = "0.5.1"
 [dev-dependencies]
 criterion = "0.5.1"
 generic-tests = "0.1.2"
+test-case = "3.3.1"
 
 [[bench]]
 name = "polynomial"

fastcrypto-tbls/src/lib.rs

@@ -22,6 +22,7 @@ pub mod random_oracle;
 pub mod tbls;
 pub mod threshold_schnorr;
 pub mod types;
+pub mod weight_reduction;
 
 // TODO: needs to use ecies_v1
 // #[cfg(any(test, feature = "experimental"))]
@@ -59,3 +60,7 @@ pub mod nodes_tests;
 #[cfg(test)]
 #[path = "tests/nizk_tests.rs"]
 pub mod nizk_tests;
+
+#[cfg(test)]
+#[path = "tests/super_swiper_test.rs"]
+pub mod super_swiper_test;

fastcrypto-tbls/src/nodes.rs

@@ -3,9 +3,13 @@
 
 use crate::ecies_v1;
 use crate::types::ShareIndex;
+use crate::weight_reduction::solve;
+use crate::weight_reduction::weight_reduction_checks::compute_precision_loss;
 use fastcrypto::error::{FastCryptoError, FastCryptoResult};
 use fastcrypto::groups::GroupElement;
 use fastcrypto::hash::{Blake2b256, Digest, HashFunction};
+use itertools::Itertools;
+use num_rational::Ratio;
 use serde::{Deserialize, Serialize};
 use tracing::debug;
 
@@ -221,4 +225,132 @@ impl<G: GroupElement + Serialize> Nodes<G> {
             new_t,
         ))
     }
+
+    /// Create a new set of nodes using the super_swiper algorithm for weight reduction.
+    /// This uses the swiper algorithms from the `weight_reduction` directory.
+    ///
+    /// # Parameters
+    /// - `nodes_vec`: Input nodes with weights
+    /// - `t`: Threshold (adversarial weight threshold in absolute terms)
+    /// - `allowed_delta`: Maximum allowed delta value
+    /// - `total_weight_lower_bound`: Minimum allowed total weight after reduction
+    ///
+    /// # Returns
+    /// A tuple of (reduced Nodes, new threshold, beta numerator, beta denominator)
+    pub fn new_super_swiper_reduced(
+        nodes_vec: Vec<Node<G>>,
+        t: u16,
+        allowed_delta: u16,
+        total_weight_lower_bound: u16,
+    ) -> FastCryptoResult<(Self, u16, Ratio<u64>)> {
+        let n = Self::new(nodes_vec)?;
+        let original_total_weight = n.total_weight() as u64;
+
+        // Validate total_weight_lower_bound (similar to new_reduced)
+        if total_weight_lower_bound > n.total_weight
+            || total_weight_lower_bound == 0
+            || original_total_weight == 0
+        {
+            return Err(FastCryptoError::InvalidInput);
+        }
+
+        let alpha = Ratio::new(t as u64, original_total_weight);
+
+        // Extract weights from nodes, sorted in descending order (required by super_swiper)
+        let weights_sorted = n
+            .nodes
+            .iter()
+            .map(|node| node.weight as u64)
+            .sorted()
+            .rev()
+            .collect_vec();
+
+        // Original weights for delta calculation (in original order)
+        let original_weights: Vec<u64> = n.nodes.iter().map(|node| node.weight as u64).collect();
+
+        // Map from sorted index back to original index (computed once, used in loop)
+        let indexed_weights: Vec<(usize, u16)> = n
+            .nodes
+            .iter()
+            .enumerate()
+            .map(|(i, node)| (i, node.weight))
+            .sorted_by_key(|(_, w)| *w)
+            .rev()
+            .collect_vec();
+
+        // Find the highest beta such that delta < allowed_delta
+        // Start high and decrease until constraint is met
+        let step = Ratio::new(1u64, 100u64);
+        let beta_min = alpha + step; // Minimum beta is alpha + 1/100
+        let beta_max = Ratio::new(1u64, 2u64); // Maximum beta is 1/2
+        let mut beta = beta_max;
+
+        loop {
+            if beta < beta_min {
+                return Err(FastCryptoError::InvalidInput);
+            }
+
+            let reduced_weights_sorted = solve(alpha, beta, &weights_sorted);
+            let new_total_weight: u64 = reduced_weights_sorted.iter().sum();
+
+            // Map reduced weights back to original order
+            let mut new_weights = vec![0u16; n.nodes.len()];
+            for (idx_in_sorted, (original_idx, _)) in indexed_weights.iter().enumerate() {
+                if idx_in_sorted < reduced_weights_sorted.len() {
+                    new_weights[*original_idx] = reduced_weights_sorted[idx_in_sorted] as u16;
+                }
+            }
+
+            let reduced_weights: Vec<u64> = new_weights.iter().copied().map(u64::from).collect();
+
+            // Compute delta = sum(max(original[i] - reduced[i] * d, 0))
+            // where d = total_original / total_reduced (exact ratio)
+            let (delta, d) = compute_precision_loss(&original_weights, &reduced_weights);
+
+            // Check condition: (2*n+1)/3 + allowed_delta - delta >= 2 * beta * n - d
+            // where n = original_total_weight
+            let n_ratio = Ratio::from_integer(original_total_weight);
+            let two_n_plus_one = Ratio::from_integer(2 * original_total_weight + 1);
+            let left_side = two_n_plus_one / Ratio::from_integer(3)
+                + Ratio::from_integer(allowed_delta as u64)
+                - delta;
+            let right_side = Ratio::from_integer(2u64) * beta * n_ratio - d;
+            let condition_met = left_side >= right_side;
+
+            let lower_bound_ok = new_total_weight >= total_weight_lower_bound as u64;
+
+            // If condition not met or lower bound not met, decrease beta
+            if !condition_met || !lower_bound_ok {
+                beta -= step;
+                continue;
+            }
+
+            // Success - build and return the result
+            let nodes = n
+                .nodes
+                .into_iter()
+                .zip(new_weights)
+                .map(|(Node { id, pk, weight: _ }, new_weight)| Node {
+                    id,
+                    pk,
+                    weight: new_weight,
+                })
+                .collect_vec();
+
+            let accumulated_weights = Self::get_accumulated_weights(&nodes);
+            let nodes_with_nonzero_weight = Self::filter_nonzero_weights(&nodes);
+            let new_t = (beta * new_total_weight).to_integer() as u16;
+
+            return Ok((
+                Self {
+                    nodes,
+                    total_weight: new_total_weight as u16,
+                    accumulated_weights,
+                    nodes_with_nonzero_weight,
+                },
+                new_t,
+                beta,
+            ));
+        }
+    }
 }