chore: Push evaluation of the linear map into CanonicalLinearRelation.

Author: mmaker

src/linear_relation/canonical.rs

@@ -13,6 +13,9 @@ use crate::errors::{Error, InvalidInstance};
 /// This struct represents a normalized form of a linear relation where each
 /// constraint is of the form: image_i = Σ (scalar_j * group_element_k)
 /// without weights or extra scalars.
+///
+/// XXX. this definition is uncomfortably similar to LinearRelation, exception made for the weights.
+/// It'd be nice to squash the two together.
 #[derive(Clone, Debug, Default)]
 pub struct CanonicalLinearRelation<G: PrimeGroup> {
     /// The image group elements (left-hand side of equations)
@@ -35,7 +38,7 @@ type WeightedGroupCache<G> = HashMap<GroupVar<G>, Vec<(<G as group::Group>::Scal
 
 impl<G: PrimeGroup> CanonicalLinearRelation<G> {
     /// Create a new empty canonical linear relation
-    pub fn new() -> Self {
+    fn new() -> Self {
         Self {
             image: Vec::new(),
             linear_combinations: Vec::new(),
@@ -44,6 +47,22 @@ impl<G: PrimeGroup> CanonicalLinearRelation<G> {
         }
     }
 
+    /// Evaluate the canonical linear relation with the provided scalars
+    pub fn evaluate(&self, scalars: &[G::Scalar]) -> Result<Vec<G>, Error> {
+        self.linear_combinations
+            .iter()
+            .map(|constraint| {
+                let mut result = G::identity();
+                for (scalar_var, group_var) in constraint {
+                    let scalar_val = scalars[scalar_var.index()];
+                    let group_val = self.group_elements.get(*group_var)?;
+                    result += group_val * scalar_val;
+                }
+                Ok(result)
+            })
+            .collect()
+    }
+
     /// Get or create a GroupVar for a weighted group element, with deduplication
     fn get_or_create_weighted_group_var(
         &mut self,
@@ -378,11 +397,10 @@ impl<G: PrimeGroup> TryFrom<&LinearRelation<G>> for CanonicalLinearRelation<G> {
                 .map_err(|_| InvalidInstance::new("Unassigned group variable in image"))?;
 
             // If the linear combination is trivial, check it directly and skip processing.
-            if rhs
-                .0
-                .iter()
-                .all(|weighted| matches!(weighted.term.scalar, ScalarTerm::Unit) || weighted.weight.is_zero_vartime())
-            {
+            if rhs.0.iter().all(|weighted| {
+                matches!(weighted.term.scalar, ScalarTerm::Unit)
+                    || weighted.weight.is_zero_vartime()
+            }) {
                 let rhs_value = rhs.0.iter().fold(G::identity(), |acc, weighted| {
                     acc + relation
                         .linear_map

src/linear_relation/mod.rs

@@ -118,23 +118,24 @@ pub type LinearCombination<G> = Sum<Weighted<Term<G>, <G as group::Group>::Scala
 
 impl<G: PrimeGroup> LinearMap<G> {
     fn map(&self, scalars: &[G::Scalar]) -> Result<Vec<G>, InvalidInstance> {
-        self.linear_combinations.iter().map(
-            |lc| {
-             let weighted_coefficients =
-                lc.0.iter()
-                    .map(|weighted| weighted.term.scalar.value(scalars) * weighted.weight)
-                    .collect::<Vec<_>>();
-            let elements =
-                lc.0.iter()
-                    .map(|weighted| self.group_elements.get(weighted.term.elem))
-                    .collect::<Result<Vec<_>, InvalidInstance>>();
-            match elements {
-                Ok(elements) => Ok(msm_pr(&weighted_coefficients, &elements)),
-                Err(error) => Err(error),
-            }
-            }
-        ).
-    collect::<Result<Vec<_>, InvalidInstance>>().into()
+        self.linear_combinations
+            .iter()
+            .map(|lc| {
+                let weighted_coefficients =
+                    lc.0.iter()
+                        .map(|weighted| weighted.term.scalar.value(scalars) * weighted.weight)
+                        .collect::<Vec<_>>();
+                let elements =
+                    lc.0.iter()
+                        .map(|weighted| self.group_elements.get(weighted.term.elem))
+                        .collect::<Result<Vec<_>, InvalidInstance>>();
+                match elements {
+                    Ok(elements) => Ok(msm_pr(&weighted_coefficients, &elements)),
+                    Err(error) => Err(error),
+                }
+            })
+            .collect::<Result<Vec<_>, InvalidInstance>>()
+            .into()
     }
 }
 
@@ -489,11 +490,7 @@ impl<G: PrimeGroup> LinearRelation<G> {
 
         let mapped_scalars = self.linear_map.map(scalars)?;
 
-        for (mapped_scalar, lhs) in iter::zip(
-            mapped_scalars,
-            &self.image,
-        ) {
-
+        for (mapped_scalar, lhs) in iter::zip(mapped_scalars, &self.image) {
             self.linear_map
                 .group_elements
                 .assign_element(*lhs, mapped_scalar)

src/schnorr_protocol.rs

@@ -38,23 +38,6 @@ impl<G: PrimeGroup> SchnorrProof<G> {
         self.0.linear_combinations.len()
     }
 
-    /// Evaluate the canonical linear relation with the provided scalars
-    fn evaluate(&self, scalars: &[G::Scalar]) -> Result<Vec<G>, Error> {
-        self.0
-            .linear_combinations
-            .iter()
-            .map(|constraint| {
-                let mut result = G::identity();
-                for (scalar_var, group_var) in constraint {
-                    let scalar_val = scalars[scalar_var.index()];
-                    let group_val = self.0.group_elements.get(*group_var)?;
-                    result += group_val * scalar_val;
-                }
-                Ok(result)
-            })
-            .collect()
-    }
-
     /// Internal method to commit using provided nonces (for deterministic testing)
     pub fn commit_with_nonces(
         &self,
@@ -80,7 +63,7 @@ impl<G: PrimeGroup> SchnorrProof<G> {
             return Err(Error::InvalidInstanceWitnessPair);
         }
 
-        let commitment = self.evaluate(nonces)?;
+        let commitment = self.0.evaluate(nonces)?;
         let prover_state = ProverState(nonces.to_vec(), witness.to_vec());
         Ok((commitment, prover_state))
     }
@@ -193,7 +176,7 @@ impl<G: PrimeGroup> SigmaProtocol for SchnorrProof<G> {
             return Err(Error::InvalidInstanceWitnessPair);
         }
 
-        let lhs = self.evaluate(response)?;
+        let lhs = self.0.evaluate(response)?;
         let mut rhs = Vec::new();
         for (i, g) in commitment.iter().enumerate() {
             rhs.push(self.0.image[i] * challenge + g);
@@ -366,7 +349,7 @@ where
             return Err(Error::InvalidInstanceWitnessPair);
         }
 
-        let response_image = self.evaluate(response)?;
+        let response_image = self.0.evaluate(response)?;
         let image = &self.0.image;
 
         let commitment = response_image

src/tests/test_validation_criteria.rs

@@ -62,7 +62,6 @@ mod instance_validation {
         relation.set_element(var_X, G::identity());
         let result = CanonicalLinearRelation::try_from(&relation);
         assert!(result.is_ok());
-
     }
 
     #[test]