Fix bugs in field utils to work for libsnark (#103)

* Fix bugs in field utils to work for libsnark

* Add more tests for common and field utils

* Update changelog

Author: alexander-zw

CHANGELOG.md

@@ -19,7 +19,10 @@ This update introduces new field and curve API's, and enforces they are used con
 - #75 Get rid of warning for unused constant PI, in complex field
 - #78 Reduce prints when inhibit_profiling_info is set
 - #79 & #87 Use std::size_t for all code, fix bugs introduced by #58
-- #94 & #96 Fix bugs that make libff incompatible with libfqfft and libiop
+- #94 & #96 Fix bugs that make libff incompatible with
+  [libfqfft](https://github.com/scipr-lab/libfqfft) and [libiop](https://github.com/scipr-lab/libiop)
+- #103 Fix bugs that make libff incompatible with [libsnark](https://github.com/scipr-lab/libsnark)
+  and add more tests for the field utils
 
 ## v0.2.0
 

libff/algebra/field_utils/field_utils.tcc

@@ -116,7 +116,7 @@ get_root_of_unity(const size_t n)
 template<typename FieldT>
 std::vector<FieldT> pack_int_vector_into_field_element_vector(const std::vector<size_t> &v, const size_t w)
 {
-    const size_t chunk_bits = FieldT::capacity();
+    const size_t chunk_bits = FieldT::floor_size_in_bits();
     const size_t repacked_size = div_ceil(v.size() * w, chunk_bits);
     std::vector<FieldT> result(repacked_size);
 
@@ -141,7 +141,7 @@ std::vector<FieldT> pack_int_vector_into_field_element_vector(const std::vector<
 template<typename FieldT>
 std::vector<FieldT> pack_bit_vector_into_field_element_vector(const bit_vector &v, const size_t chunk_bits)
 {
-    assert(chunk_bits <= FieldT::capacity());
+    assert(chunk_bits <= FieldT::floor_size_in_bits());
 
     const size_t repacked_size = div_ceil(v.size(), chunk_bits);
     std::vector<FieldT> result(repacked_size);
@@ -162,7 +162,7 @@ std::vector<FieldT> pack_bit_vector_into_field_element_vector(const bit_vector &
 template<typename FieldT>
 std::vector<FieldT> pack_bit_vector_into_field_element_vector(const bit_vector &v)
 {
-    return pack_bit_vector_into_field_element_vector<FieldT>(v, FieldT::capacity());
+    return pack_bit_vector_into_field_element_vector<FieldT>(v, FieldT::floor_size_in_bits());
 }
 
 template<typename FieldT>

libff/algebra/field_utils/tests/test_field_utils.cpp

@@ -8,12 +8,16 @@
  * @copyright  MIT license (see LICENSE file)
  *****************************************************************************/
 #include "libff/algebra/field_utils/bigint.hpp"
+#include "libff/algebra/field_utils/field_utils.hpp"
 #include "libff/algebra/field_utils/algorithms.hpp"
 #include "libff/algebra/fields/binary/gf64.hpp"
+#include "libff/algebra/curves/edwards/edwards_fields.hpp"
 #include <gtest/gtest.h>
 
 using namespace libff;
 
+using std::size_t;
+
 template<typename FieldT>
 FieldT power_naive(const FieldT &base, const std::size_t exponent)
 {
@@ -98,3 +102,56 @@ TEST(FieldUtilsTest, BigintTest)
     x.clear();
     EXPECT_EQ(x, zero);
 }
+
+TEST(FieldUtilsTest, FieldVectorConversionTest)
+{
+    init_edwards_fields();
+
+    // pack_bit_vector_into_field_element_vector
+
+    bit_vector vec;
+    for (size_t i = 0; i < 12 + edwards_Fq::ceil_size_in_bits(); i++)
+        vec.push_back(0);
+    vec.push_back(1);
+    vec.push_back(0);
+    vec.push_back(1);
+
+    std::vector<edwards_Fq> field_vec = pack_bit_vector_into_field_element_vector<edwards_Fq>(vec);
+
+    EXPECT_EQ(field_vec.size(), 2);
+    EXPECT_EQ(field_vec[0], edwards_Fq::zero());
+    EXPECT_EQ(field_vec[1], edwards_Fq(40960)); // 5 * 2**13
+
+    // convert_bit_vector_to_field_element_vector
+
+    bit_vector vec2;
+    vec2.push_back(0);
+    vec2.push_back(0);
+    vec2.push_back(1);
+    vec2.push_back(0);
+    vec2.push_back(1);
+
+    field_vec = convert_bit_vector_to_field_element_vector<edwards_Fq>(vec2);
+
+    EXPECT_EQ(field_vec.size(), 5);
+    EXPECT_EQ(field_vec[0], edwards_Fq::zero());
+    EXPECT_EQ(field_vec[1], edwards_Fq::zero());
+    EXPECT_EQ(field_vec[2], edwards_Fq::one());
+    EXPECT_EQ(field_vec[3], edwards_Fq::zero());
+    EXPECT_EQ(field_vec[4], edwards_Fq::one());
+
+    // convert_field_element_vector_to_bit_vector
+
+    std::vector<edwards_Fq> field_vec2;
+    field_vec2.push_back(edwards_Fq(edwards_Fq(5)));
+    field_vec2.push_back(edwards_Fq::zero());
+
+    bit_vector vec3 = convert_field_element_vector_to_bit_vector(field_vec2);
+
+    EXPECT_EQ(vec3.size(), edwards_Fq::ceil_size_in_bits() * 2);
+    EXPECT_EQ(vec3[0], 1);
+    EXPECT_EQ(vec3[1], 0);
+    EXPECT_EQ(vec3[2], 1);
+    for (size_t i = 3; i < vec3.size(); i++)
+        EXPECT_EQ(vec3[i], 0);
+}

libff/common/tests/test_common.cpp

@@ -11,6 +11,9 @@
 #include <gtest/gtest.h>
 
 #include "libff/common/utils.hpp"
+#include "libff/algebra/fields/binary/gf32.hpp"
+#include "libff/algebra/curves/edwards/edwards_pp.hpp"
+#include "libff/algebra/curves/mnt/mnt6/mnt6_pp.hpp"
 
 using namespace libff;
 
@@ -37,3 +40,48 @@ TEST(Log2Test, PowersOfTwo) {
         EXPECT_EQ(libff::log2(k+1), i+1);
     }
 }
+
+template<typename FieldT>
+void test_random_element()
+{
+    FieldT x = random_element_non_zero_one<FieldT>();
+    EXPECT_NE(x, FieldT::zero());
+    EXPECT_NE(x, FieldT::one());
+
+    x = random_element_non_zero<FieldT>();
+    EXPECT_NE(x, FieldT::zero());
+
+    FieldT y = random_element_exclude(x);
+    EXPECT_NE(x, y);
+}
+
+TEST(UtilsTest, RandomElementTest)
+{
+    init_edwards_fields();
+    test_random_element<edwards_Fq3>();
+    test_random_element<gf32>();
+}
+
+TEST(UtilsTest, CurveVectorSizeTest)
+{
+    init_edwards_params();
+    init_mnt6_params();
+
+    std::vector<edwards_G1> vec;
+
+    vec.push_back(edwards_G1::G1_one);
+    vec.push_back(edwards_G1::G1_zero);
+    vec.push_back(edwards_G1::G1_one);
+
+    EXPECT_EQ(curve_size_in_bits(vec), 552);
+
+    std::vector<mnt6_G2> vec2;
+
+    vec2.push_back(mnt6_G2::G2_zero);
+    vec2.push_back(mnt6_G2::G2_one);
+    vec2.push_back(mnt6_G2::G2_one);
+    vec2.push_back(mnt6_G2::G2_zero);
+    vec2.push_back(mnt6_G2::G2_zero);
+
+    EXPECT_EQ(curve_size_in_bits(vec2), 4475);
+}

libff/common/utils.hpp

@@ -61,8 +61,9 @@ void UNUSED(Types&&...) {}
 void serialize_bit_vector(std::ostream &out, const bit_vector &v);
 void deserialize_bit_vector(std::istream &in, bit_vector &v);
 
-template<typename T>
-std::size_t ceil_size_in_bits(const std::vector<T> &v);
+/** Should not be used for fields, because the field function is named ceil_size_in_bits instead. */
+template<typename CurveT>
+std::size_t curve_size_in_bits(const std::vector<CurveT> &v);
 
 /* Print a vector in the form { elem0 elem1 elem2 ... }, with a newline at the end
 template<typename T>

libff/common/utils.tcc

@@ -13,10 +13,10 @@ namespace libff {
 
 using std::size_t;
 
-template<typename T>
-size_t ceil_size_in_bits(const std::vector<T> &v)
+template<typename CurveT>
+size_t curve_size_in_bits(const std::vector<CurveT> &v)
 {
-    return v.size() * T::ceil_size_in_bits();
+    return v.size() * CurveT::size_in_bits();
 }
 
 template<typename T>