rename CouplePoint to ProductPoint

Author: GiacomoPope

src/protocols/sqisign.rs

@@ -9,7 +9,7 @@ use sha3::{
 
 use crate::{
     elliptic::{basis::BasisX, curve::Curve},
-    theta::elliptic_product::{CouplePoint, EllipticProduct},
+    theta::elliptic_product::{EllipticProduct, ProductPoint},
     utilities::le_bytes::byte_slice_difference,
 };
 
@@ -388,15 +388,15 @@ impl<Fq: FqTrait> Sqisign<Fq> {
         E2: &Curve<Fq>,
         B1: &BasisX<Fq>,
         B2: &BasisX<Fq>,
-    ) -> (EllipticProduct<Fq>, CouplePoint<Fq>, CouplePoint<Fq>) {
+    ) -> (EllipticProduct<Fq>, ProductPoint<Fq>, ProductPoint<Fq>) {
         let E1E2 = EllipticProduct::new(E1, E2);
         // TODO: lift_basis requires an inversion, we could write a function
         // which normallises B1 and B2 simultaneously to save one inversion
         // here.
         let (P_chl, Q_chl) = E1.lift_basis(&B1);
         let (P_aux, Q_aux) = E2.lift_basis(&B2);
-        let P1P2 = CouplePoint::new(&P_chl, &P_aux);
-        let Q1Q2 = CouplePoint::new(&Q_chl, &Q_aux);
+        let P1P2 = ProductPoint::new(&P_chl, &P_aux);
+        let Q1Q2 = ProductPoint::new(&Q_chl, &Q_aux);
 
         (E1E2, P1P2, Q1Q2)
     }

src/theta/elliptic_product.rs

@@ -3,12 +3,12 @@ use fp2::fq::Fq as FqTrait;
 use crate::elliptic::{curve::Curve, projective_point::Point};
 
 #[derive(Clone, Copy, Debug)]
-pub struct CouplePoint<Fq: FqTrait> {
+pub struct ProductPoint<Fq: FqTrait> {
     P1: Point<Fq>,
     P2: Point<Fq>,
 }
 
-impl<Fq: FqTrait> CouplePoint<Fq> {
+impl<Fq: FqTrait> ProductPoint<Fq> {
     /// Return the pair of points at infinity: O1, O2 on E1 x E2
     pub const INFINITY: Self = Self {
         P1: Point::INFINITY,
@@ -26,7 +26,7 @@ impl<Fq: FqTrait> CouplePoint<Fq> {
     }
 }
 
-impl<Fq: FqTrait> ::std::fmt::Display for CouplePoint<Fq> {
+impl<Fq: FqTrait> ::std::fmt::Display for ProductPoint<Fq> {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         write!(f, "CouplePoint with Points:\n{}\n{}", self.P1, self.P2)
     }
@@ -53,15 +53,15 @@ impl<Fq: FqTrait> EllipticProduct<Fq> {
     /// Addition of elements (P1, P2) and (Q1, Q2) on E1 x E2 is defined
     /// as (P1 + Q1, P2 + Q2). This function calls the add function for
     /// the pair of curves on the EllipticProduct
-    pub fn add(self, C1: &CouplePoint<Fq>, C2: &CouplePoint<Fq>) -> CouplePoint<Fq> {
-        let mut C3 = CouplePoint::INFINITY;
+    pub fn add(self, C1: &ProductPoint<Fq>, C2: &ProductPoint<Fq>) -> ProductPoint<Fq> {
+        let mut C3 = ProductPoint::INFINITY;
         C3.P1 = self.E1.add(&C1.P1, &C2.P1);
         C3.P2 = self.E2.add(&C1.P2, &C2.P2);
         C3
     }
 
     /// Doubles the pair of points (P1, P2) on E1 x E2 as ([2]P1, [2]P2)
-    pub fn double(self, C: &CouplePoint<Fq>) -> CouplePoint<Fq> {
+    pub fn double(self, C: &ProductPoint<Fq>) -> ProductPoint<Fq> {
         let mut C3 = *C;
         C3.P1 = self.E1.double(&C3.P1);
         C3.P2 = self.E2.double(&C3.P2);
@@ -70,7 +70,7 @@ impl<Fq: FqTrait> EllipticProduct<Fq> {
 
     /// Repeatedly doubles the pair of points (P1, P2) on E1 x E2 to get
     /// ([2^n]P1, [2^n]P2)
-    pub fn double_iter(self, C: &CouplePoint<Fq>, n: usize) -> CouplePoint<Fq> {
+    pub fn double_iter(self, C: &ProductPoint<Fq>, n: usize) -> ProductPoint<Fq> {
         let mut C3 = *C;
         C3.P1 = self.E1.double_iter(&C3.P1, n);
         C3.P2 = self.E2.double_iter(&C3.P2, n);

src/theta/theta_chain.rs

@@ -1,6 +1,6 @@
 use fp2::fq::Fq as FqTrait;
 
-use super::elliptic_product::{CouplePoint, EllipticProduct};
+use super::elliptic_product::{EllipticProduct, ProductPoint};
 use super::theta_gluing::gluing_isogeny;
 use super::theta_isogeny::{two_isogeny, two_isogeny_to_product};
 use super::theta_point::ThetaPoint;
@@ -16,11 +16,11 @@ use super::theta_splitting::{split_to_product, splitting_isomorphism};
 impl<Fq: FqTrait> EllipticProduct<Fq> {
     pub fn elliptic_product_isogeny_no_strategy(
         self,
-        P1P2: &CouplePoint<Fq>,
-        Q1Q2: &CouplePoint<Fq>,
+        P1P2: &ProductPoint<Fq>,
+        Q1Q2: &ProductPoint<Fq>,
         n: usize,
-        image_points: &[CouplePoint<Fq>],
-    ) -> (EllipticProduct<Fq>, Vec<CouplePoint<Fq>>) {
+        image_points: &[ProductPoint<Fq>],
+    ) -> (EllipticProduct<Fq>, Vec<ProductPoint<Fq>>) {
         // Store the number of image points we wish to evaluate to
         // ensure we return them all from the points we push through
         let num_image_points = image_points.len();

src/theta/theta_gluing.rs

@@ -8,7 +8,7 @@
 // compatible with the isogeny formula
 // ========================================================
 
-use super::elliptic_product::{CouplePoint, EllipticProduct};
+use super::elliptic_product::{EllipticProduct, ProductPoint};
 use super::theta_point::ThetaPoint;
 use super::theta_structure::ThetaStructure;
 use super::theta_util::{apply_base_change, to_hadamard};
@@ -54,8 +54,8 @@ fn get_base_submatrix<Fq: FqTrait>(E: &Curve<Fq>, T: &Point<Fq>) -> (Fq, Fq, Fq,
 /// Cost 100M + 8S + 4I
 fn get_base_matrix<Fq: FqTrait>(
     E1E2: &EllipticProduct<Fq>,
-    P1P2: &CouplePoint<Fq>,
-    Q1Q2: &CouplePoint<Fq>,
+    P1P2: &ProductPoint<Fq>,
+    Q1Q2: &ProductPoint<Fq>,
 ) -> [Fq; 16] {
     // First compute the submatrices from each point
     let (E1, E2) = E1E2.curves();
@@ -132,7 +132,7 @@ fn get_base_matrix<Fq: FqTrait>(
 /// Given a couple point as input, compute the corresponding ThetaPoint on
 /// the level two structure and then apply the basis change on this point
 /// Cost: 20M
-fn base_change_couple_point<Fq: FqTrait>(P1P2: &CouplePoint<Fq>, M: [Fq; 16]) -> ThetaPoint<Fq> {
+fn base_change_couple_point<Fq: FqTrait>(P1P2: &ProductPoint<Fq>, M: [Fq; 16]) -> ThetaPoint<Fq> {
     let (P1, P2) = P1P2.points();
     let (mut X1, mut Z1) = P1.to_xz();
     let (mut X2, mut Z2) = P2.to_xz();
@@ -295,9 +295,9 @@ fn gluing_image<Fq: FqTrait>(
 /// from an elliptic product.
 pub fn gluing_isogeny<Fq: FqTrait>(
     E1E2: &EllipticProduct<Fq>,
-    P1P2_8: &CouplePoint<Fq>,
-    Q1Q2_8: &CouplePoint<Fq>,
-    image_points: &[CouplePoint<Fq>],
+    P1P2_8: &ProductPoint<Fq>,
+    Q1Q2_8: &ProductPoint<Fq>,
+    image_points: &[ProductPoint<Fq>],
 ) -> (ThetaStructure<Fq>, Vec<ThetaPoint<Fq>>) {
     // First recover the four torsion below the 8 torsion
     let P1P2_4 = E1E2.double(&P1P2_8);

src/theta/theta_splitting.rs

@@ -9,7 +9,7 @@ use fp2::fq::Fq as FqTrait;
 use crate::elliptic::curve::Curve;
 use crate::elliptic::point::PointX;
 
-use super::elliptic_product::{CouplePoint, EllipticProduct};
+use super::elliptic_product::{EllipticProduct, ProductPoint};
 use super::theta_point::ThetaPoint;
 use super::theta_structure::ThetaStructure;
 use super::theta_util::apply_base_change;
@@ -413,7 +413,7 @@ pub fn split_to_product<Fq: FqTrait>(
     Th: &ThetaStructure<Fq>,
     image_points: &[ThetaPoint<Fq>],
     num_image_points: usize,
-) -> (EllipticProduct<Fq>, Vec<CouplePoint<Fq>>) {
+) -> (EllipticProduct<Fq>, Vec<ProductPoint<Fq>>) {
     // First we take the domain theta null point and
     // split this to two level-1 theta null points
     let null_point = Th.null_point();
@@ -426,8 +426,8 @@ pub fn split_to_product<Fq: FqTrait>(
     let E3E4 = EllipticProduct::new(&E3, &E4);
 
     // Now compute points on E3 x E4
-    let mut C: CouplePoint<Fq>;
-    let mut couple_points: Vec<CouplePoint<Fq>> = vec![];
+    let mut C: ProductPoint<Fq>;
+    let mut couple_points: Vec<ProductPoint<Fq>> = vec![];
 
     for P in image_points.iter().take(num_image_points) {
         // Split to level 1
@@ -442,7 +442,7 @@ pub fn split_to_product<Fq: FqTrait>(
 
         // Package these points into a CouplePoint on
         // E3 x E4
-        C = CouplePoint::new(&Q1, &Q2);
+        C = ProductPoint::new(&Q1, &Q2);
 
         // Push this into the output
         couple_points.push(C);

tests/test_product_isogeny.rs

@@ -4,7 +4,7 @@
 mod test_product_isogeny {
     use isogeny::{
         elliptic::{curve::Curve, projective_point::Point},
-        theta::elliptic_product::{CouplePoint, EllipticProduct},
+        theta::elliptic_product::{EllipticProduct, ProductPoint},
     };
 
     // Modulus used in test
@@ -72,13 +72,13 @@ mod test_product_isogeny {
         let P2 = Point::new_xy(&P2_X, &P2_Y);
         let Q1 = Point::new_xy(&Q1_X, &Q1_Y);
         let Q2 = Point::new_xy(&Q2_X, &Q2_Y);
-        let P1P2 = CouplePoint::new(&P1, &P2);
-        let Q1Q2 = CouplePoint::new(&Q1, &Q2);
+        let P1P2 = ProductPoint::new(&P1, &P2);
+        let Q1Q2 = ProductPoint::new(&Q1, &Q2);
 
         // Point to push through isogeny
         let PA = Point::INFINITY;
         let PB = Point::new_xy(&PA_X, &PA_Y);
-        let PAPB = CouplePoint::new(&PA, &PB);
+        let PAPB = ProductPoint::new(&PA, &PB);
         let image_points = [PAPB];
 
         // Points to compare against