feat: Commit (#61)

* wip: scalar mult wrangling

* bug: tests run forever

* merge in changes

* chore: commitment is type at infinity

* feat: more tests and sanity checks

Author: 0xJepsen

math/curve.sage

@@ -58,4 +58,16 @@ g1SRS = [(2**i)*G1 for i in range(7)]
 print(g1SRS)
 
 g2SRS = [(2**i)*G2 for i in range(2)]
-print(g2SRS)
+print(g2SRS)
+
+
+######################################################################
+GF17 = GF(17)
+
+coefs = [11, 11, 11, 1]
+# 11 * g1_srs[0] + 11 * g1_srs[1] + 11 * g1_srs[2] + 1 * g1_srs[3]
+muls  = [(coefs[i] * g1SRS[i]) for i in range(4)] 
+commitment = sum(muls)
+print(commitment)
+
+

src/curves/mod.rs

@@ -40,14 +40,7 @@ pub enum AffinePoint<C: EllipticCurve> {
 
 impl<C: EllipticCurve> AffinePoint<C> {
   /// Create a new point on the curve so long as it satisfies the curve equation.
-  ///
-  /// ## Panics
-  /// If the point is not on the curve; validated by checking if `y^2 = x^3 + ax + b`.
   pub fn new(x: C::BaseField, y: C::BaseField) -> Self {
-    // okay so this is breaking because the curve equation doesn't know how to plug in polynomials.
-    // y = 31x -> y^2 = 52x^2
-    // x = 36 -> x^3 = 95 + 3
-    // 52x^2 = 98 ???
     assert_eq!(
       y * y,
       x * x * x + C::EQUATION_A.into() * x + C::EQUATION_B.into(),
@@ -74,22 +67,18 @@ impl<C: EllipticCurve> Neg for AffinePoint<C> {
 
 // TODO: This should likely use a `Self::ScalarField` instead of `u32`.
 /// Scalar multiplication on the rhs: P*(u32)
+/// This is the niave implementation of scalar multiplication
+/// There is a faster way to do this but this is simpler to reason about for now
+#[allow(clippy::suspicious_arithmetic_impl)]
 impl<C: EllipticCurve> Mul<u32> for AffinePoint<C> {
   type Output = AffinePoint<C>;
 
-  fn mul(self, scalar: u32) -> Self::Output {
-    let mut result = AffinePoint::Infinity;
-    let mut base = self;
-    let mut exp = scalar;
-
-    while exp > 0 {
-      if exp % 2 == 1 {
-        result = result + base;
-      }
-      base = base.point_doubling();
-      exp /= 2;
+  fn mul(mut self, scalar: u32) -> Self::Output {
+    let val = self;
+    for _ in 1..scalar {
+      self = self + val;
     }
-    result
+    self
   }
 }
 
@@ -157,7 +146,7 @@ impl<C: EllipticCurve> AffinePoint<C> {
       AffinePoint::PointOnCurve(x, y) => (x, y),
       AffinePoint::Infinity => panic!("Cannot double point at infinity"),
     };
-    // m = (3x^2) / (2y)
+    // m = (3x^2) + a / (2y) (a = 0 on our curve)
     let m = ((C::BaseField::TWO + C::BaseField::ONE) * x * x) / (C::BaseField::TWO * y);
 
     // 2P = (m^2 - 2x, m(3x - m^2)- y)

src/field/gf_101.rs

@@ -10,7 +10,7 @@ pub const PLUTO_FIELD_PRIME: u32 = 101;
 
 /// [`GF101`] represents the finite field GF(101) that has 101 elements and works with typical sum
 /// and multiplication operations modulo 101.
-#[derive(Copy, Clone, Default, Debug, Hash, PartialEq, Eq)]
+#[derive(Copy, Clone, Default, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct GF101 {
   value: u32,
 }

src/field/mod.rs

@@ -20,6 +20,7 @@ pub trait FiniteField:
   + Clone
   + PartialEq
   + Eq
+  + PartialOrd
   + Add<Output = Self>
   + AddAssign
   + Sum
@@ -122,7 +123,7 @@ where [B; N + 1]: {
 /// A struct that represents an element of an extension field. The element is represented as
 /// [`Monomial`] coefficients of a [`Polynomial`] of degree `N - 1` over the base [`FiniteField`]
 /// `F`.
-#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug, PartialOrd)]
 pub struct Ext<const N: usize, F: FiniteField> {
   pub(crate) coeffs: [F; N],
 }
@@ -297,19 +298,36 @@ pub fn get_generator(p: u32) -> i32 {
   }
   -1
 }
-
-fn powmod(base: u32, exponent: u32, modulus: u32) -> u32 {
-  let mut base = base as u64;
+//
+/// Computes the power of a base raised to an exponent under modulo using the method of
+/// Exponentiation by Squaring.
+///
+/// This method is used for its efficiency in calculating large powers of a number in modular
+/// arithmetic, which is a common operation in many cryptographic algorithms. It reduces the number
+/// of multiplications needed by squaring the base and halving the exponent in each step, thus
+/// operating in O(log exponent) time.
+///
+/// # Arguments
+/// * `base` - The base number as a `u32`.
+/// * `exponent` - The exponent as a `u32`.
+/// * `modulus` - The modulus as a `u32`.
+///
+/// # Returns
+/// * The result of (base^exponent) % modulus as a `u32`.
+pub fn powmod(base: u32, exponent: u32, modulus: u32) -> u32 {
+  let mut base = base as u64; // Use u64 to prevent overflow during calculations
   let mut exponent = exponent;
   let modulus = modulus as u64;
-  let mut result = 1;
-  base %= modulus;
+  let mut result = 1; // Start with the multiplicative identity
+  base %= modulus; // Reduce base modulo initially to simplify further calculations
+
   while exponent > 0 {
     if exponent % 2 == 1 {
+      // If the exponent is odd, multiply the current result by the base
       result = (result * base) % modulus;
     }
-    base = (base * base) % modulus;
-    exponent >>= 1;
+    base = (base * base) % modulus; // Square the base
+    exponent >>= 1; // Divide the exponent by 2
   }
-  result as u32
+  result as u32 // Return the result as u32
 }

src/setup.rs

@@ -2,8 +2,10 @@
 
 use super::*;
 
+/// simple setup to get params.
 #[allow(dead_code, clippy::type_complexity)]
-fn setup() -> (Vec<AffinePoint<PlutoCurve<GF101>>>, Vec<AffinePoint<PlutoCurve<Ext<2, GF101>>>>) {
+pub fn setup() -> (Vec<AffinePoint<PlutoCurve<GF101>>>, Vec<AffinePoint<PlutoCurve<Ext<2, GF101>>>>)
+{
   // NOTE: For demonstration purposes only.
 
   // This is just tau from plonk by hand, it is not actually secure
@@ -33,6 +35,28 @@ fn setup() -> (Vec<AffinePoint<PlutoCurve<GF101>>>, Vec<AffinePoint<PlutoCurve<E
   (srs_g1_points, srs_g2_points)
 }
 
+/// kzg poly commit
+#[allow(dead_code)]
+fn commit(
+  coefs: Vec<u32>,
+  g1_srs: Vec<AffinePoint<PlutoCurve<GF101>>>,
+) -> AffinePoint<PlutoCurve<GF101>> {
+  // commit to a polynomial
+  // - given a polynomial, commit to it
+  assert!(g1_srs.len() >= coefs.len());
+  // Todo implement multiplication with field elements as scalar mult.
+  // Maybe having the scalar mult be around the base field like colin suggested is better
+
+  let mut commitment = AffinePoint::Infinity;
+  for (coef, point) in coefs.iter().zip(g1_srs) {
+    let res = point * *coef;
+    // println!("res {:?}, of multiplying point {:?}, and coef {:?}", res, point, coef);
+    println!("commitment {:?} before addition with {:?}", commitment, res);
+    commitment = commitment + res;
+  }
+  commitment
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -51,6 +75,7 @@ mod tests {
       AffinePoint::<PlutoCurve<GF101>>::new(GF101::new(68), GF101::new(27)),
       AffinePoint::<PlutoCurve<GF101>>::new(GF101::new(65), GF101::new(3)),
     ];
+
     assert_eq!(g1srs, expected_g1srs);
 
     println!("g2srs {:?}", g2srs);
@@ -64,4 +89,33 @@ mod tests {
 
     assert_eq!(g2srs, expected_g2srs);
   }
+
+  #[test]
+  fn test_commit() {
+    let (g1srs, _) = setup();
+    // p(x) = (x-1)(x-2)(x-3)
+    // p(x) = x^3 - 6x^2 + 11x - 6
+    // -> -6 mod 17 is 11 so this is [1, 11, 11, 1]
+    let coefficients = vec![11, 11, 11, 1];
+    //  g1srs[0] * 11 + g1srs[1] * 11 + g1srs[2] * 11 + g1srs[3] * 1
+    let commit_1 = commit(coefficients, g1srs.clone());
+    assert_eq!(commit_1, AffinePoint::<PlutoCurve<GF101>>::Infinity);
+
+    // p(x) = (x-1)(x-2)(x-3)(x-4)
+    // p(x) = x^4 - 10x^3 + 35x^2 - 50x + 24
+    // -> 24 mod 17 is 7
+    // -> 50 mod 17 is 16
+    // -> 35 mod 17 is 1
+    // coefficients = [7, 16, 1, 11, 1]
+    let coefficients = vec![7, 16, 1, 11, 1];
+    //  g1srs[0] * 7 + g1srs[1] * 16 + g1srs[2] * 1 + g1srs[3] * 11 + g1srs[4] * 1
+    let commit_2 = commit(coefficients, g1srs.clone());
+    assert_eq!(commit_2, AffinePoint::<PlutoCurve<GF101>>::new(GF101::new(32), GF101::new(59)));
+
+    // p(x)  = x^2 + 2x + 3
+    let coefficients = vec![3, 2, 1];
+    // g1srs[0] * 3 + g1srs[1] * 2  + g1srs[2] * 1
+    let commit_3 = commit(coefficients, g1srs);
+    assert_eq!(commit_3, AffinePoint::<PlutoCurve<GF101>>::new(GF101::new(32), GF101::new(59)));
+  }
 }