Improve MSM documentation & add vector size check (#75)

* chore: improve Multi-Scalar Multiplication module documentation and add vector size validation

Enhanced the documentation for the MSM module to improve clarity and usability.
Added a check to ensure scalar and point vectors have matching lengths, preventing
potential runtime errors.

* chore: rename module multi_scalar_mul to msm

Renamed the module from multi_scalar_mul to msm for brevity and improved readability.

Author: nougzarm

src/linear_relation/canonical.rs

@@ -8,7 +8,7 @@ use subtle::{Choice, ConstantTimeEq};
 
 use super::{GroupMap, GroupVar, LinearCombination, LinearRelation, ScalarTerm, ScalarVar};
 use crate::errors::{Error, InvalidInstance};
-use crate::linear_relation::multi_scalar_mul::VariableMultiScalarMul;
+use crate::linear_relation::msm::VariableMultiScalarMul;
 
 /// A normalized form of the [`LinearRelation`], which is used for serialization into the transcript.
 ///

src/linear_relation/mod.rs

@@ -28,8 +28,8 @@ mod canonical;
 pub use canonical::CanonicalLinearRelation;
 
 /// Implementation of multi-scalar multiplication (MSM) over scalars and points.
-mod multi_scalar_mul;
-pub use multi_scalar_mul::VariableMultiScalarMul;
+mod msm;
+pub use msm::VariableMultiScalarMul;
 
 /// A wrapper representing an index for a scalar variable.
 ///

src/linear_relation/msm.rs

@@ -0,0 +1,58 @@
+use group::prime::PrimeGroup;
+
+/// Trait for performing Multi-Scalar Multiplication (MSM).
+///
+/// MSM computes the sum:
+/// ```text
+/// result = Σ (scalar[i] * point[i])
+/// ```
+/// Implementations can override this with optimized algorithms for specific groups,
+/// while a default naive implementation is provided for all [`PrimeGroup`] types.
+pub trait VariableMultiScalarMul {
+    /// The scalar field type associated with the group.
+    type Scalar;
+    /// The group element (point) type.
+    type Point;
+
+    /// Computes the multi-scalar multiplication (MSM) over the provided scalars and points.
+    ///
+    /// # Parameters
+    /// - `scalars`: Slice of scalar multipliers.
+    /// - `bases`: Slice of group elements to be multiplied by the scalars.
+    ///
+    /// # Returns
+    /// The resulting group element from the MSM computation.
+    ///
+    /// # Panics
+    /// Panics if `scalars.len() != bases.len()`.
+    fn msm(scalars: &[Self::Scalar], bases: &[Self::Point]) -> Self;
+}
+
+impl<G: PrimeGroup> VariableMultiScalarMul for G {
+    type Scalar = G::Scalar;
+    type Point = G;
+
+    /// Default naive MSM implementation for any [`PrimeGroup`].
+    ///
+    /// This method performs a straightforward sum of scalar multiplications:
+    /// ```text
+    /// Σ (scalar[i] * point[i])
+    /// ```
+    /// Complexity: **O(n)** group multiplications and additions.
+    ///
+    /// # Panics
+    /// Panics if `scalars.len() != bases.len()`.
+    fn msm(scalars: &[Self::Scalar], bases: &[Self::Point]) -> Self {
+        assert_eq!(
+            scalars.len(),
+            bases.len(),
+            "scalars and bases must have the same length"
+        );
+
+        let mut acc = Self::identity();
+        for (s, p) in scalars.iter().zip(bases.iter()) {
+            acc += *p * s;
+        }
+        acc
+    }
+}