feat: (mostly) generic fields (#63)

* feat: gf17

* feat: rework of prime fields

* chore: cleanup `prime` module

* feat: big field rework

* fix + fmt

* remove ICE files

we don't need to listen to the compiler whine

* cleanup + clippy

* add: type aliases and their docs

* rename to `curve`

* clean up

* add: notes on `find_generator` function

* feat: readme + cleanup

* merge + fix one test

Author: Autoparallel

Cargo.lock

@@ -8,9 +8,8 @@ repository ="https://github.com/thor314/ronkathon"
 version    ="0.1.0"
 
 [dependencies]
-rand      ="0.8"
-serde     ={ version="1.0", default-features=false, features=["derive"] }
-num-bigint={ version="0.4.5", default-features=false }
+rand      ="0.8.5"
+num-bigint={ version="0.4.3", default-features=false }
 ark-std   ={ version="0.4.0", default-features=false }
 ark-bn254 ="0.4.0"
 ark-poly  ="0.4.0"

Cargo.toml

@@ -14,7 +14,10 @@ pub trait EllipticCurve: Copy {
   type BaseField: FiniteField;
 
   /// Order of this elliptic curve, i.e. number of elements in the scalar field.
-  const ORDER: u32;
+  type ScalarField: FiniteField;
+
+  /// Order of this elliptic curve, i.e. number of elements in the scalar field.
+  const ORDER: usize = Self::ScalarField::ORDER;
 
   /// Coefficient `a` in the Weierstrass equation of this elliptic curve.
   const EQUATION_A: Self::Coefficient;
@@ -127,8 +130,8 @@ impl<C: EllipticCurve> Add for AffinePoint<C> {
     // compute new point using elliptic curve point group law
     // https://en.wikipedia.org/wiki/Elliptic_curve_point_multiplication
     let lambda = if x1 == x2 && y1 == y2 {
-      ((C::BaseField::TWO + C::BaseField::ONE) * x1 * x1 + C::EQUATION_A.into())
-        / (C::BaseField::TWO * y1)
+      ((C::BaseField::ONE + C::BaseField::ONE + C::BaseField::ONE) * x1 * x1 + C::EQUATION_A.into())
+        / ((C::BaseField::ONE + C::BaseField::ONE) * y1)
     } else {
       (y2 - y1) / (x2 - x1)
     };
@@ -146,12 +149,13 @@ impl<C: EllipticCurve> AffinePoint<C> {
       AffinePoint::PointOnCurve(x, y) => (x, y),
       AffinePoint::Infinity => panic!("Cannot double point at infinity"),
     };
-    // m = (3x^2) + a / (2y) (a = 0 on our curve)
-    let m = ((C::BaseField::TWO + C::BaseField::ONE) * x * x) / (C::BaseField::TWO * y);
+    // m = (3x^2) / (2y)
+    let m = (((C::BaseField::ONE + C::BaseField::ONE) + C::BaseField::ONE) * x * x)
+      / ((C::BaseField::ONE + C::BaseField::ONE) * y);
 
     // 2P = (m^2 - 2x, m(3x - m^2)- y)
-    let x_new = m * m - C::BaseField::TWO * x;
-    let y_new = m * ((C::BaseField::TWO + C::BaseField::ONE) * x - m * m) - y;
+    let x_new = m * m - (C::BaseField::ONE + C::BaseField::ONE) * x;
+    let y_new = m * ((C::BaseField::ONE + C::BaseField::ONE + C::BaseField::ONE) * x - m * m) - y;
     AffinePoint::new(x_new, y_new)
   }
 

src/curves/mod.rs src/curve/mod.rssrc/curves/mod.rs renamed to src/curve/mod.rs

@@ -0,0 +1,220 @@
+//! This module contains the constants and methods for the Pluto curve over the prime field `GF101`
+//! and its extensions.
+//!
+//! The basic idea here is that we have a curve that fixes `EQUATION_A` to 0 and `EQUATION_B` to 3.
+//! The rest of the properties of the curve depend solely on the field for which we define it over.
+//! This interface allows us to have an easily swappable curve definition for different fields.
+//!
+//! Note that this would be cleaner if we could use trait specialization to keep the default
+//! implementations in the trait itself, but this feature is not yet to that point of utility.
+
+use super::*;
+
+/// The [`PlutoBaseCurve`] is an the base field set to the [`PlutoBaseField`]. This is the curve
+/// used in the Pluto `ronkathon` system. The curve is defined by the equation `y^2 = x^3 + 3`.
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
+pub struct PlutoBaseCurve;
+
+/// The [`PlutoExtendedCurve`] is an instance of the same curve as the [`PlutoBaseCurve`], but with
+/// field set to the [`PlutoBaseFieldExtension`].
+///
+/// This is the curve used in the Pluto `ronkathon`  system. The curve is defined by the equation
+/// `y^2 = x^3 + 3`, but the field is extended to the quadratic extension field over the base field.
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
+pub struct PlutoExtendedCurve;
+
+impl EllipticCurve for PlutoBaseCurve {
+  type BaseField = PlutoBaseField;
+  type Coefficient = PlutoBaseField;
+  type ScalarField = PlutoScalarField;
+
+  const EQUATION_A: Self::Coefficient = PlutoBaseField::ZERO;
+  const EQUATION_B: Self::Coefficient = PlutoBaseField::new(3);
+  const GENERATOR: (Self::BaseField, Self::BaseField) =
+    (PlutoBaseField::ONE, PlutoBaseField::new(2));
+}
+
+impl EllipticCurve for PlutoExtendedCurve {
+  type BaseField = PlutoBaseFieldExtension;
+  type Coefficient = PlutoBaseField;
+  // TODO: This scalar field is not correct yet. We need to implement the correct scalar field for
+  // the extension field as `PlutoScalarFieldExtension`
+  type ScalarField = PlutoScalarField;
+
+  const EQUATION_A: Self::Coefficient = PlutoBaseField::ZERO;
+  const EQUATION_B: Self::Coefficient = PlutoBaseField::new(3);
+  const GENERATOR: (Self::BaseField, Self::BaseField) = (
+    PlutoBaseFieldExtension::new([PlutoBaseField::new(36), PlutoBaseField::ZERO]),
+    PlutoBaseFieldExtension::new([PlutoBaseField::ZERO, PlutoBaseField::new(31)]),
+  );
+}
+
+#[cfg(test)]
+mod pluto_base_curve_tests {
+  use super::*;
+
+  #[test]
+  fn point_doubling() {
+    let g = AffinePoint::<PlutoBaseCurve>::generator();
+
+    let two_g = g.point_doubling();
+    let expected_2g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(68), PlutoBaseField::new(74));
+    let expected_negative_2g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(68), PlutoBaseField::new(27));
+    assert_eq!(two_g, expected_2g);
+    assert_eq!(-two_g, expected_negative_2g);
+
+    let four_g = two_g.point_doubling();
+    let expected_4g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(65), PlutoBaseField::new(98));
+    let expected_negative_4g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(65), PlutoBaseField::new(3));
+    assert_eq!(four_g, expected_4g);
+    assert_eq!(-four_g, expected_negative_4g);
+
+    let eight_g = four_g.point_doubling();
+    let expected_8g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(18), PlutoBaseField::new(49));
+    let expected_negative_8g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(18), PlutoBaseField::new(52));
+    assert_eq!(eight_g, expected_8g);
+    assert_eq!(-eight_g, expected_negative_8g);
+
+    let sixteen_g = eight_g.point_doubling();
+    let expected_16g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(1), PlutoBaseField::new(99));
+    let expected_negative_16g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(1), PlutoBaseField::new(2));
+    assert_eq!(sixteen_g, expected_16g);
+    assert_eq!(-sixteen_g, expected_negative_16g);
+    assert_eq!(g, -sixteen_g);
+  }
+
+  #[test]
+  fn order_17() {
+    let g = AffinePoint::<PlutoBaseCurve>::generator();
+    let mut g_double = g.point_doubling();
+    let mut count = 2;
+    while g_double != g && -g_double != g {
+      g_double = g_double.point_doubling();
+      count *= 2;
+    }
+    assert_eq!(count + 1, 17);
+  }
+
+  #[test]
+  fn point_addition() {
+    let g = AffinePoint::<PlutoBaseCurve>::generator();
+    let two_g = g.point_doubling();
+    let three_g = g + two_g;
+    let expected_3g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(26), PlutoBaseField::new(45));
+    let expected_negative_3g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(26), PlutoBaseField::new(56));
+    assert_eq!(three_g, expected_3g);
+    assert_eq!(-three_g, expected_negative_3g);
+
+    let four_g = g + three_g;
+    let expected_4g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(65), PlutoBaseField::new(98));
+    let expected_negative_4g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(65), PlutoBaseField::new(3));
+    assert_eq!(four_g, expected_4g);
+    assert_eq!(-four_g, expected_negative_4g);
+
+    let five_g = g + four_g;
+    let expected_5g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(12), PlutoBaseField::new(32));
+    let expected_negative_5g =
+      AffinePoint::<PlutoBaseCurve>::new(PlutoBaseField::new(12), PlutoBaseField::new(69));
+    assert_eq!(five_g, expected_5g);
+    assert_eq!(-five_g, expected_negative_5g);
+
+    assert_eq!(g + AffinePoint::Infinity, g);
+    assert_eq!(AffinePoint::Infinity + g, g);
+    assert_eq!(g + (-g), AffinePoint::Infinity);
+  }
+
+  #[test]
+  fn scalar_multiplication_rhs() {
+    let g = AffinePoint::<PlutoBaseCurve>::generator();
+    let two_g = g * 2;
+    let expected_2g = g.point_doubling();
+    assert_eq!(two_g, expected_2g);
+    assert_eq!(-two_g, -expected_2g);
+  }
+
+  #[test]
+  fn scalar_multiplication_lhs() {
+    let g = AffinePoint::<PlutoBaseCurve>::generator();
+    let two_g = 2 * g;
+    let expected_2g = g.point_doubling();
+    assert_eq!(two_g, expected_2g);
+    assert_eq!(-two_g, -expected_2g);
+  }
+}
+
+#[cfg(test)]
+mod pluto_extended_curve_tests {
+  use super::*;
+
+  fn point() -> AffinePoint<PlutoExtendedCurve> {
+    AffinePoint::<PlutoExtendedCurve>::new(
+      PlutoBaseFieldExtension::new([PlutoBaseField::new(90), PlutoBaseField::ZERO]),
+      PlutoBaseFieldExtension::new([PlutoBaseField::ZERO, PlutoBaseField::new(82)]),
+    )
+  }
+
+  fn false_point() -> AffinePoint<PlutoExtendedCurve> {
+    AffinePoint::<PlutoExtendedCurve>::new(
+      PlutoBaseFieldExtension::new([PlutoBaseField::new(36), PlutoBaseField::ZERO]),
+      PlutoBaseFieldExtension::new([PlutoBaseField::ZERO, PlutoBaseField::new(81)]),
+    )
+  }
+
+  fn generator() -> AffinePoint<PlutoExtendedCurve> {
+    AffinePoint::<PlutoExtendedCurve>::new(
+      PlutoBaseFieldExtension::new([PlutoBaseField::new(36), PlutoBaseField::ZERO]),
+      PlutoBaseFieldExtension::new([PlutoBaseField::ZERO, PlutoBaseField::new(31)]),
+    )
+  }
+
+  #[rstest]
+  #[case(AffinePoint::<PlutoExtendedCurve>::generator())]
+  #[case(generator())]
+  #[case(point())]
+  #[should_panic]
+  #[case(false_point())]
+  fn on_curve(#[case] p: AffinePoint<PlutoExtendedCurve>) { let _ = p; }
+
+  #[test]
+  fn point_doubling() {
+    let g = AffinePoint::<PlutoExtendedCurve>::generator();
+    let two_g = g.point_doubling();
+
+    let expected_g = generator();
+    let expected_two_g = point();
+
+    assert_eq!(two_g, expected_two_g);
+    assert_eq!(g, expected_g);
+  }
+
+  #[test]
+  fn scalar_multiplication_rhs() {
+    let g = AffinePoint::<PlutoExtendedCurve>::generator();
+    let two_g = g * 2;
+    let expected_two_g = g.point_doubling();
+    assert_eq!(two_g, expected_two_g);
+    assert_eq!(-two_g, -expected_two_g);
+  }
+
+  #[test]
+  fn scalar_multiplication_lhs() {
+    let g = AffinePoint::<PlutoExtendedCurve>::generator();
+    let two_g = 2 * g;
+    let expected_two_g = g.point_doubling();
+    assert_eq!(two_g, expected_two_g);
+    assert_eq!(-two_g, -expected_two_g);
+  }
+}