Add MINUS_ONE to Field, FpConfig (#1004)

* Add `MINUS_ONE` to `Field`, `FpConfig`

* Fix comment

* Fix comments

---------

Co-authored-by: Weikeng Chen <w.k@berkeley.edu>

Author: Pratyush

ff/src/fields/mod.rs

@@ -207,6 +207,9 @@ pub trait Field:
     /// The multiplicative identity of the field.
     const ONE: Self;
 
+    /// Negation of the multiplicative identity of the field.
+    const NEG_ONE: Self;
+
     /// Returns the characteristic of the field,
     /// in little-endian representation.
     fn characteristic() -> &'static [u64] {

ff/src/fields/models/cubic_extension.rs

@@ -186,6 +186,12 @@ impl<P: CubicExtConfig> Field for CubicExtField<P> {
 
     const ONE: Self = Self::new(P::BaseField::ONE, P::BaseField::ZERO, P::BaseField::ZERO);
 
+    const NEG_ONE: Self = Self::new(
+        P::BaseField::NEG_ONE,
+        P::BaseField::ZERO,
+        P::BaseField::ZERO,
+    );
+
     fn extension_degree() -> u64 {
         3 * P::BaseField::extension_degree()
     }

ff/src/fields/models/fp/mod.rs

@@ -40,6 +40,9 @@ pub trait FpConfig<const N: usize>: Send + Sync + 'static + Sized {
     /// such that, for all elements `f` of the field, `e * f = f`.
     const ONE: Fp<Self, N>;
 
+    /// Negation of `Self::ONE`.
+    const NEG_ONE: Fp<Self, N>;
+
     /// Let `N` be the size of the multiplicative group defined by the field.
     /// Then `TWO_ADICITY` is the two-adicity of `N`, i.e. the integer `s`
     /// such that `N = 2^s * t` for some odd integer `t`.
@@ -211,6 +214,7 @@ impl<P: FpConfig<N>, const N: usize> Field for Fp<P, N> {
 
     const SQRT_PRECOMP: Option<SqrtPrecomputation<Self>> = P::SQRT_PRECOMP;
     const ONE: Self = P::ONE;
+    const NEG_ONE: Self = P::NEG_ONE;
 
     fn extension_degree() -> u64 {
         1

ff/src/fields/models/fp/montgomery_backend.rs

@@ -610,6 +610,9 @@ impl<T: MontConfig<N>, const N: usize> FpConfig<N> for MontBackend<T, N> {
     /// such that, for all elements `f` of the field, `e * f = f`.
     const ONE: Fp<Self, N> = Fp::new_unchecked(T::R);
 
+    /// Negation of `Self::ONE`.
+    const NEG_ONE: Fp<Self, N> = Fp::new_unchecked(Self::MODULUS.const_sub_with_borrow(&T::R).0);
+
     const TWO_ADICITY: u32 = Self::MODULUS.two_adic_valuation();
     const TWO_ADIC_ROOT_OF_UNITY: Fp<Self, N> = T::TWO_ADIC_ROOT_OF_UNITY;
     const SMALL_SUBGROUP_BASE: Option<u32> = T::SMALL_SUBGROUP_BASE;

ff/src/fields/models/quadratic_extension.rs

@@ -212,6 +212,8 @@ impl<P: QuadExtConfig> Field for QuadExtField<P> {
 
     const ONE: Self = Self::new(P::BaseField::ONE, P::BaseField::ZERO);
 
+    const NEG_ONE: Self = Self::new(P::BaseField::NEG_ONE, P::BaseField::ZERO);
+
     fn extension_degree() -> u64 {
         2 * P::BaseField::extension_degree()
     }
@@ -270,7 +272,7 @@ impl<P: QuadExtConfig> Field for QuadExtField<P> {
         //            = (c0^2 + beta * c1^2, 2 c0 * c1)
         // Where beta is P::NONRESIDUE.
         // When beta = -1, we can re-use intermediate additions to improve performance.
-        if P::NONRESIDUE == -P::BaseField::ONE {
+        if P::NONRESIDUE == P::BaseField::NEG_ONE {
             // When the non-residue is -1, we save 2 intermediate additions,
             // and use one fewer intermediate variable
 

serialize/src/test.rs

@@ -1,5 +1,3 @@
-use std::collections::{HashMap, HashSet};
-
 use super::*;
 use ark_std::{
     collections::{BTreeMap, BTreeSet, LinkedList, VecDeque},
@@ -288,9 +286,11 @@ fn test_btreeset() {
     test_serialize(set);
 }
 
+#[cfg(feature = "std")]
 #[test]
 #[allow(clippy::zero_sized_map_values)]
 fn test_hashmap() {
+    use std::collections::HashMap;
     let mut map = HashMap::new();
     map.insert(0u64, Dummy);
     map.insert(5u64, Dummy);
@@ -301,8 +301,11 @@ fn test_hashmap() {
     test_serialize(map);
 }
 
+#[cfg(feature = "std")]
 #[test]
 fn test_hashset() {
+    use std::collections::HashSet;
+
     let mut set = HashSet::new();
     set.insert(Dummy);
     set.insert(Dummy);

test-templates/src/fields.rs

@@ -215,11 +215,14 @@ macro_rules! __test_field {
             let mut rng = test_rng();
             let zero = <$field>::zero();
             let one = <$field>::one();
+            let minus_one = <$field>::NEG_ONE;
             assert_eq!(one.inverse().unwrap(), one, "One inverse failed");
             assert!(one.is_one(), "One is not one");
 
             assert!(<$field>::ONE.is_one(), "One constant is not one");
             assert_eq!(<$field>::ONE, one, "One constant is incorrect");
+            assert_eq!(<$field>::NEG_ONE, -one, "NEG_ONE constant is incorrect");
+            assert_eq!(<$field>::ONE + <$field>::NEG_ONE, zero, "1 + -1 neq 0");
 
             for _ in 0..ITERATIONS {
                 // Associativity
@@ -235,6 +238,7 @@ macro_rules! __test_field {
                 assert_eq!(one * a, a, "Identity mul failed");
                 assert_eq!(one * b, b, "Identity mul failed");
                 assert_eq!(one * c, c, "Identity mul failed");
+                assert_eq!(minus_one * c, -c, "NEG_ONE mul failed");
 
                 assert_eq!(zero * a, zero, "Mul by zero failed");
                 assert_eq!(zero * b, zero, "Mul by zero failed");