feat(morphism): add single allocation functions to Morphism

- feat: implement single allocate_x functions for Morphism structure

Author: nougzarm

src/group_morphism.rs

@@ -9,7 +9,6 @@
 //! - [`GroupMorphismPreimage`]: a higher-level structure managing morphisms and their associated images
 
 use group::{Group, GroupEncoding};
-use std::iter::repeat_n;
 
 /// A wrapper representing an index for a scalar variable.
 ///
@@ -168,10 +167,12 @@ where
         self.morphism.num_statements() * repr_len // total size of a commit
     }
 
-    /// Append a new equation relating scalars to group elements.
+    /// Adds a new equation to the statement of the form:
+    /// `lhs = Σ (scalar_i * point_i)`
+    /// 
     /// # Parameters
-    /// - `lhs`: The image group element variable (left-hand side of the equation).
-    /// - `rhs`: A slice of `(ScalarVar, PointVar)` pairs representing the linear combination on the right-hand side.
+    /// - `lhs`: The variable representing the left-hand group element
+    /// - `rhs`: A list of (scalar variable, point variable) tuples for the linear combination
     pub fn append_equation(&mut self, lhs: PointVar, rhs: &[(ScalarVar, PointVar)]) {
         let lc = LinearCombination {
             scalar_indices: rhs.iter().map(|&(s, _)| s).collect(),
@@ -181,6 +182,12 @@ where
         self.image.push(lhs);
     }
 
+    /// Allocates a scalar variable for use in the morphism.
+    pub fn allocate_scalar(&mut self) -> ScalarVar {
+        self.morphism.num_scalars += 1;
+        ScalarVar(self.morphism.num_scalars - 1)
+    }
+
     /// Allocates space for `n` new scalar variables.
     ///
     /// # Parameters
@@ -189,9 +196,13 @@ where
     /// # Returns
     /// A vector of [`ScalarVar`] representing the newly allocated scalar indices.
     pub fn allocate_scalars(&mut self, n: usize) -> Vec<ScalarVar> {
-        let start = self.morphism.num_scalars;
-        self.morphism.num_scalars += n;
-        (start..start + n).map(ScalarVar).collect()
+        (0..n).map(|_| self.allocate_scalar()).collect()
+    }
+
+    /// Allocates a point variable (group element) for use in the morphism.
+    pub fn allocate_element(&mut self) -> PointVar {
+        self.morphism.group_elements.push(G::identity());
+        PointVar(self.morphism.group_elements.len() - 1)
     }
 
     /// Allocates space for `n` new group elements, initialized to the identity element.
@@ -202,20 +213,25 @@ where
     /// # Returns
     /// A vector of [`PointVar`] representing the newly allocated group element indices.
     pub fn allocate_elements(&mut self, n: usize) -> Vec<PointVar> {
-        let start = self.morphism.group_elements.len();
-        self.morphism
-            .group_elements
-            .extend(repeat_n(G::identity(), n));
-        (start..start + n).map(PointVar).collect::<Vec<_>>()
+        (0..n).map(|_| self.allocate_element()).collect()
+    }
+
+    /// Assign a group element value to a point variable.
+    ///
+    /// # Parameters
+    /// - `var`: The variable to assign.
+    /// - `element`: The value to assign to the variable.
+    pub fn assign_element(&mut self, var: PointVar, element: G) {
+        self.morphism.group_elements[var.0] = element;
     }
 
-    /// Sets the values of group elements at specified indices.
+    /// Assigns specific group elements to point variables (indices).
     ///
     /// # Parameters
-    /// - `elements`: A slice of `(PointVar, G)` tuples specifying which elements to update and their new values.
-    pub fn set_elements(&mut self, elements: &[(PointVar, G)]) {
-        for &(i, elt) in elements {
-            self.morphism.group_elements[i.0] = elt;
+    /// - `elements`: A list of `(PointVar, GroupElement)` pairs
+    pub fn assign_elements(&mut self, elements: &[(PointVar, G)]) {
+        for (var, element) in elements {
+            self.assign_element(*var, *element)
         }
     }
 

src/proof_builder.rs

@@ -81,8 +81,8 @@ where
     ///
     /// # Parameters
     /// - `elements`: A list of `(PointVar, GroupElement)` pairs.
-    pub fn set_elements(&mut self, elements: &[(PointVar, G)]) {
-        self.protocol.sigmap.set_elements(elements);
+    pub fn assign_elements(&mut self, elements: &[(PointVar, G)]) {
+        self.protocol.sigmap.assign_elements(elements);
     }
 
     /// Returns the expected group element results (`lhs`) of the current equations.

src/schnorr_protocol.rs

@@ -54,8 +54,8 @@ impl<G: Group + GroupEncoding> SchnorrProtocol<G> {
         self.0.allocate_elements(n)
     }
 
-    pub fn set_elements(&mut self, elements: &[(PointVar, G)]) {
-        self.0.set_elements(elements);
+    pub fn assign_elements(&mut self, elements: &[(PointVar, G)]) {
+        self.0.assign_elements(elements);
     }
 
     pub fn evaluate(&self, scalars: &[<G as Group>::Scalar]) -> Vec<G> {

tests/morphism_preimage.rs

@@ -26,13 +26,13 @@ fn discrete_logarithm<G: Group + GroupEncoding>(
     morphismp.append_equation(var_X, &[(var_x, var_G)]);
 
     let G = G::generator();
-    morphismp.set_elements(&[(var_G, G)]);
+    morphismp.assign_elements(&[(var_G, G)]);
 
     let x = G::Scalar::random(&mut *rng);
     let X = G * x;
     assert!(vec![X] == morphismp.morphism.evaluate(&[x]));
 
-    morphismp.set_elements(&[(var_X, X)]);
+    morphismp.assign_elements(&[(var_X, X)]);
     (morphismp, vec![x])
 }
 
@@ -54,7 +54,7 @@ fn dleq<G: Group + GroupEncoding>(
     let points = morphismp.allocate_elements(4);
     let (var_G, var_H, var_X, var_Y) = (points[0], points[1], points[2], points[3]);
 
-    morphismp.set_elements(&[(var_G, G), (var_H, H), (var_X, X), (var_Y, Y)]);
+    morphismp.assign_elements(&[(var_G, G), (var_H, H), (var_X, X), (var_Y, Y)]);
     morphismp.append_equation(var_X, &[(var_x, var_G)]);
     morphismp.append_equation(var_Y, &[(var_x, var_H)]);
 
@@ -82,7 +82,7 @@ fn pedersen_commitment<G: Group + GroupEncoding>(
     let points = cs.allocate_elements(3);
     let (var_G, var_H, var_C) = (points[0], points[1], points[2]);
 
-    cs.set_elements(&[(var_H, H), (var_G, G), (var_C, C)]);
+    cs.assign_elements(&[(var_H, H), (var_G, G), (var_C, C)]);
     cs.append_equation(var_C, &[(var_x, var_G), (var_r, var_H)]);
 
     assert!(vec![C] == cs.morphism.evaluate(&witness));
@@ -114,13 +114,13 @@ fn pedersen_commitment_dleq<G: Group + GroupEncoding>(
     let var_Gs = (points[0], points[1], points[2], points[3]);
     let (var_X, var_Y) = (points[4], points[5]);
 
-    morphismp.set_elements(&[
+    morphismp.assign_elements(&[
         (var_Gs.0, generators[0]),
         (var_Gs.1, generators[1]),
         (var_Gs.2, generators[2]),
         (var_Gs.3, generators[3]),
     ]);
-    morphismp.set_elements(&[(var_X, X), (var_Y, Y)]);
+    morphismp.assign_elements(&[(var_X, X), (var_Y, Y)]);
 
     morphismp.append_equation(var_X, &[(var_x, var_Gs.0), (var_r, var_Gs.1)]);
     morphismp.append_equation(var_Y, &[(var_x, var_Gs.2), (var_r, var_Gs.3)]);
@@ -164,7 +164,7 @@ fn bbs_blind_commitment_computation<G: Group + GroupEncoding>(
     let (var_Q_2, var_J_1, var_J_2, var_J_3) = (points[0], points[1], points[2], points[3]);
     let var_C = points[M + 1];
 
-    morphismp.set_elements(&[
+    morphismp.assign_elements(&[
         (var_Q_2, Q_2),
         (var_J_1, J_1),
         (var_J_2, J_2),

tests/proof_builder.rs

@@ -22,12 +22,12 @@ fn discrete_logarithm() {
     proof_builder.append_equation(var_X, &[(var_x, var_G)]);
 
     let G = G::generator();
-    proof_builder.set_elements(&[(var_G, G)]);
+    proof_builder.assign_elements(&[(var_G, G)]);
 
     let witness = vec![Scalar::random(rng)];
 
     let X = G * witness[0];
-    proof_builder.set_elements(&[(var_X, X)]);
+    proof_builder.assign_elements(&[(var_X, X)]);
 
     // Prove and verify a proof
     let proof_bytes = proof_builder.prove(&witness, &mut rng).unwrap();

tests/proof_composition.rs

@@ -25,8 +25,8 @@ fn DL_protocol<G: Group + GroupEncoding>(
     let points = preimage.allocate_elements(2);
 
     preimage.append_equation(points[1], &[(scalars[0], points[0])]);
-    preimage.set_elements(&[(points[0], G)]);
-    preimage.set_elements(&[(points[1], G * x)]);
+    preimage.assign_elements(&[(points[0], G)]);
+    preimage.assign_elements(&[(points[1], G * x)]);
 
     assert!(vec![G * x] == preimage.morphism.evaluate(&[x]));
     (SchnorrProtocol::from_preimage(preimage), vec![x])
@@ -49,7 +49,7 @@ fn pedersen_protocol<G: Group + GroupEncoding>(
     let scalars = preimage.allocate_scalars(2);
     let points = preimage.allocate_elements(3);
 
-    preimage.set_elements(&[(points[1], H), (points[0], G), (points[2], C)]);
+    preimage.assign_elements(&[(points[1], H), (points[0], G), (points[2], C)]);
     preimage.append_equation(
         points[2],
         &[(scalars[0], points[0]), (scalars[1], points[1])],

tests/spec/sage_test_vectors.rs

@@ -84,12 +84,12 @@ fn discrete_logarithm<G: SRandom + Group + GroupEncoding>(
     morphismp.append_equation(var_X, &[(var_x, var_G)]);
 
     let G = G::generator();
-    morphismp.set_elements(&[(var_G, G)]);
+    morphismp.assign_elements(&[(var_G, G)]);
 
     let x = G::srandom(rng);
     let X = G * x;
     assert!(vec![X] == morphismp.morphism.evaluate(&[x]));
-    morphismp.set_elements(&[(var_X, X)]);
+    morphismp.assign_elements(&[(var_X, X)]);
     (morphismp, vec![x])
 }
 
@@ -111,7 +111,7 @@ fn dleq<G: Group + GroupEncoding + SRandom>(
     let points = morphismp.allocate_elements(4);
     let (var_G, var_H, var_X, var_Y) = (points[0], points[1], points[2], points[3]);
 
-    morphismp.set_elements(&[(var_G, G), (var_H, H), (var_X, X), (var_Y, Y)]);
+    morphismp.assign_elements(&[(var_G, G), (var_H, H), (var_X, X), (var_Y, Y)]);
     morphismp.append_equation(var_X, &[(var_x, var_G)]);
     morphismp.append_equation(var_Y, &[(var_x, var_H)]);
 
@@ -139,7 +139,7 @@ fn pedersen_commitment<G: Group + GroupEncoding + SRandom>(
     let points = morphismp.allocate_elements(3);
     let (var_G, var_H, var_C) = (points[0], points[1], points[2]);
 
-    morphismp.set_elements(&[(var_H, H), (var_G, G), (var_C, C)]);
+    morphismp.assign_elements(&[(var_H, H), (var_G, G), (var_C, C)]);
     morphismp.append_equation(var_C, &[(var_x, var_G), (var_r, var_H)]);
 
     assert!(vec![C] == morphismp.morphism.evaluate(&witness));
@@ -171,13 +171,13 @@ fn pedersen_commitment_dleq<G: Group + GroupEncoding + SRandom>(
     let var_Gs = (points[0], points[1], points[2], points[3]);
     let (var_X, var_Y) = (points[4], points[5]);
 
-    morphismp.set_elements(&[
+    morphismp.assign_elements(&[
         (var_Gs.0, generators[0]),
         (var_Gs.1, generators[1]),
         (var_Gs.2, generators[2]),
         (var_Gs.3, generators[3]),
     ]);
-    morphismp.set_elements(&[(var_X, X), (var_Y, Y)]);
+    morphismp.assign_elements(&[(var_X, X), (var_Y, Y)]);
 
     morphismp.append_equation(var_X, &[(var_x, var_Gs.0), (var_r, var_Gs.1)]);
     morphismp.append_equation(var_Y, &[(var_x, var_Gs.2), (var_r, var_Gs.3)]);
@@ -217,7 +217,7 @@ fn bbs_blind_commitment_computation<G: Group + GroupEncoding + SRandom>(
     let (var_Q_2, var_J_1, var_J_2, var_J_3) = (points[0], points[1], points[2], points[3]);
     let var_C = points[M + 1];
 
-    morphismp.set_elements(&[
+    morphismp.assign_elements(&[
         (var_Q_2, Q_2),
         (var_J_1, J_1),
         (var_J_2, J_2),