rewrite tests, add bls12 field, update random elements generation #107

Author: CblPOK-git

include/nil/blueprint/components/algebra/fields/plonk/exponentiation.hpp

@@ -124,7 +124,7 @@ namespace nil {
 
                 };
 
-                template<typename BlueprintFieldType, typename ArithmetizationParams, std::size_t ExponentSize, std::int32_t WitnessesAmount>
+                template<typename BlueprintFieldType, typename ArithmetizationParams, std::size_t ExponentSize, std::uint32_t WitnessesAmount>
                 using plonk_exponentiation =
                     exponentiation<
                         crypto3::zk::snark::plonk_constraint_system<BlueprintFieldType, ArithmetizationParams>,

test/algebra/curves/plonk/endo_scalar.cpp

@@ -33,7 +33,7 @@
 #include <nil/crypto3/algebra/fields/arithmetic_params/pallas.hpp>
 #include <nil/crypto3/algebra/curves/vesta.hpp>
 #include <nil/crypto3/algebra/fields/arithmetic_params/vesta.hpp>
-#include <nil/crypto3/algebra/random_element.hpp>
+#include <nil/crypto3/random/algebraic_engine.hpp>
 
 #include <nil/crypto3/hash/algorithm/hash.hpp>
 #include <nil/crypto3/hash/sha2.hpp>
@@ -47,9 +47,94 @@
 
 #include "test_plonk_component.hpp"
 
+template<typename CurveType>
+struct endo_scalar_params;
+
+template<>
+struct endo_scalar_params<nil::crypto3::algebra::curves::vesta> {
+    using curve_type = nil::crypto3::algebra::curves::vesta;
+    using scalar_field_type = typename curve_type::scalar_field_type;
+    using base_field_type = typename curve_type::base_field_type;
+    constexpr static const typename scalar_field_type::value_type endo_r =
+        0x12CCCA834ACDBA712CAAD5DC57AAB1B01D1F8BD237AD31491DAD5EBDFDFE4AB9_cppui255;
+    constexpr static const typename base_field_type::value_type endo_q =
+        0x2D33357CB532458ED3552A23A8554E5005270D29D19FC7D27B7FD22F0201B547_cppui255;
+};
+
+template<>
+struct endo_scalar_params<nil::crypto3::algebra::curves::pallas> {
+    using curve_type = nil::crypto3::algebra::curves::pallas;
+    using scalar_field_type = typename curve_type::scalar_field_type;
+    using base_field_type = typename curve_type::base_field_type;
+    constexpr static const typename scalar_field_type::value_type endo_r =
+        0x397E65A7D7C1AD71AEE24B27E308F0A61259527EC1D4752E619D1840AF55F1B1_cppui255;
+    constexpr static const typename base_field_type::value_type endo_q =
+        0x2D33357CB532458ED3552A23A8554E5005270D29D19FC7D27B7FD22F0201B547_cppui255;
+};
+
+template<typename CurveType, std::size_t ScalarSize>
+typename CurveType::scalar_field_type::value_type calculate_endo_scalar(typename CurveType::scalar_field_type::value_type scalar) {
+
+    using endo_params = endo_scalar_params<CurveType>;
+    using BlueprintFieldType = typename CurveType::scalar_field_type;
+
+    typename BlueprintFieldType::value_type endo_r = endo_params::endo_r;
+
+    const std::size_t crumbs_per_row = 8;
+    const std::size_t bits_per_crumb = 2;
+    const std::size_t bits_per_row =
+        bits_per_crumb * crumbs_per_row;    // we suppose that ScalarSize % bits_per_row = 0
+
+    typename BlueprintFieldType::integral_type integral_scalar =
+        typename BlueprintFieldType::integral_type(scalar.data);
+    std::array<bool, ScalarSize> bits_msb;
+    {
+        nil::marshalling::status_type status;
+        assert(ScalarSize <= 255);
+        std::array<bool, 255> bits_msb_all =
+            nil::marshalling::pack<nil::marshalling::option::big_endian>(integral_scalar, status);
+        assert(status == nil::marshalling::status_type::success);
+        std::copy(bits_msb_all.end() - ScalarSize, bits_msb_all.end(), bits_msb.begin());
+                            
+        for(std::size_t i = 0; i < 255 - ScalarSize; ++i) {
+            assert(bits_msb_all[i] == false);
+        }
+    }
+    typename BlueprintFieldType::value_type a = 2;
+    typename BlueprintFieldType::value_type b = 2;
+    typename BlueprintFieldType::value_type n = 0;
+
+    assert (ScalarSize % bits_per_row == 0);
+    for (std::size_t chunk_start = 0; chunk_start < bits_msb.size(); chunk_start += bits_per_row) {
+        for (std::size_t j = 0; j < crumbs_per_row; j++) {
+            std::size_t crumb = chunk_start + j * bits_per_crumb;
+            typename BlueprintFieldType::value_type b0 = static_cast<int>(bits_msb[crumb + 1]);
+            typename BlueprintFieldType::value_type b1 = static_cast<int>(bits_msb[crumb + 0]);
+
+            typename BlueprintFieldType::value_type crumb_value = b0 + b1.doubled();
+
+            a = a.doubled();
+            b = b.doubled();
+
+            typename BlueprintFieldType::value_type s =
+                (b0 == BlueprintFieldType::value_type::one()) ? 1 : -1;
+            if (b1 == BlueprintFieldType::value_type::zero()) {
+                b += s;
+            } else {
+                a += s;
+            }
+
+            n = (n.doubled()).doubled();
+            n += crumb_value;
+        }
+    }
+    auto res = a * endo_r + b;
+    return res;
+}
+
 template <typename CurveType>
 void test_endo_scalar(std::vector<typename CurveType::scalar_field_type::value_type> public_input,
-    typename CurveType::scalar_field_type::value_type expected_res){
+            typename CurveType::scalar_field_type::value_type expected_res){
     using BlueprintFieldType = typename CurveType::scalar_field_type;
     constexpr std::size_t WitnessColumns = 15;
     constexpr std::size_t PublicInputColumns = 1;
@@ -70,8 +155,14 @@ void test_endo_scalar(std::vector<typename CurveType::scalar_field_type::value_t
     var challenge_var(0, 0, false, var::column_type::public_input);
     typename component_type::input_type instance_input = {challenge_var};
 
-    auto result_check = [&expected_res](AssignmentType &assignment, 
+    auto result_check = [&expected_res, public_input](AssignmentType &assignment, 
 	    typename component_type::result_type &real_res) {
+            #ifdef BLUEPRINT_PLONK_PROFILING_ENABLED
+            std::cout << "endo_scalar input: " << std::hex << public_input[0].data << "\n";
+            std::cout << "expected result  : " << std::hex << expected_res.data << "\n";
+            std::cout << "real result      : " << std::hex << var_value(assignment, real_res.output).data << "\n\n";
+            #endif
+
             assert(expected_res == var_value(assignment, real_res.output));
     };
 
@@ -80,18 +171,59 @@ void test_endo_scalar(std::vector<typename CurveType::scalar_field_type::value_t
     nil::crypto3::test_component<component_type, BlueprintFieldType, ArithmetizationParams, hash_type, Lambda> (component_instance, public_input, result_check, instance_input);
 }
 
+constexpr static const std::size_t random_tests_amount = 10;
+
 BOOST_AUTO_TEST_SUITE(blueprint_plonk_endo_scalar_test_suite)
 
-BOOST_AUTO_TEST_CASE(blueprint_plonk_unified_addition_addition) {
+BOOST_AUTO_TEST_CASE(blueprint_plonk_endo_scalar_vesta) {
     using curve_type = nil::crypto3::algebra::curves::vesta;
     using BlueprintFieldType = typename curve_type::scalar_field_type;
-    
+
     typename BlueprintFieldType::value_type challenge = 0x00000000000000000000000000000000FC93536CAE0C612C18FBE5F6D8E8EEF2_cppui255;
     typename BlueprintFieldType::value_type result = 0x004638173549A4C55A118327904B54E5F6F6314225C8C862F5AFA2506C77AC65_cppui255;
 
-    std::vector<typename BlueprintFieldType::value_type> public_input = {challenge};
-    
-	test_endo_scalar<curve_type>(public_input, result);
+	test_endo_scalar<curve_type>({challenge}, result);
+	test_endo_scalar<curve_type>({1}, calculate_endo_scalar<curve_type, 128>(1));
+	test_endo_scalar<curve_type>({0}, calculate_endo_scalar<curve_type, 128>(0));
+	test_endo_scalar<curve_type>({0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui255}, 
+        calculate_endo_scalar<curve_type, 128>(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui255));
+
+    nil::crypto3::random::algebraic_engine<curve_type::scalar_field_type> generate_random;
+    boost::random::mt19937 seed_seq;
+    generate_random.seed(seed_seq);
+
+    for (std::size_t i = 0; i < random_tests_amount; i++){
+        typename curve_type::scalar_field_type::value_type input = generate_random();
+    	typename curve_type::scalar_field_type::integral_type input_integral = typename curve_type::scalar_field_type::integral_type(input.data);
+        input_integral = input_integral & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui255;
+    	typename curve_type::scalar_field_type::value_type input_scalar =  input_integral;
+        test_endo_scalar<curve_type>({input_scalar}, calculate_endo_scalar<curve_type, 128>(input_scalar));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(blueprint_plonk_endo_scalar_pallas) {
+    using curve_type = nil::crypto3::algebra::curves::pallas;
+    using BlueprintFieldType = typename curve_type::scalar_field_type;
+
+    typename BlueprintFieldType::value_type challenge = 0x00000000000000000000000000000000FC93536CAE0C612C18FBE5F6D8E8EEF2_cppui255;
+
+	test_endo_scalar<curve_type>({challenge}, calculate_endo_scalar<curve_type, 128>(challenge));
+	test_endo_scalar<curve_type>({1}, calculate_endo_scalar<curve_type, 128>(1));
+	test_endo_scalar<curve_type>({0}, calculate_endo_scalar<curve_type, 128>(0));
+	test_endo_scalar<curve_type>({0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui255}, 
+        calculate_endo_scalar<curve_type, 128>(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui255));
+
+    nil::crypto3::random::algebraic_engine<curve_type::scalar_field_type> generate_random;
+    boost::random::mt19937 seed_seq;
+    generate_random.seed(seed_seq);
+
+    for (std::size_t i = 0; i < random_tests_amount; i++){
+        typename curve_type::scalar_field_type::value_type input = generate_random();
+    	typename curve_type::scalar_field_type::integral_type input_integral = typename curve_type::scalar_field_type::integral_type(input.data);
+        input_integral = input_integral & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui255;
+    	typename curve_type::scalar_field_type::value_type input_scalar =  input_integral;
+        test_endo_scalar<curve_type>({input_scalar}, calculate_endo_scalar<curve_type, 128>(input_scalar));
+	}
 }
 
 BOOST_AUTO_TEST_SUITE_END()

test/algebra/curves/plonk/unified_addition.cpp

@@ -28,9 +28,11 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <nil/crypto3/algebra/curves/vesta.hpp>
+#include <nil/crypto3/algebra/fields/arithmetic_params/vesta.hpp>
 #include <nil/crypto3/algebra/curves/pallas.hpp>
 #include <nil/crypto3/algebra/fields/arithmetic_params/pallas.hpp>
-#include <nil/crypto3/algebra/random_element.hpp>
+#include <nil/crypto3/random/algebraic_engine.hpp>
 
 #include <nil/crypto3/hash/keccak.hpp>
 
@@ -70,8 +72,15 @@ void test_unified_addition(std::vector<typename CurveType::base_field_type::valu
         {var(0, 0, false, var::column_type::public_input), var(0, 1, false, var::column_type::public_input)},
         {var(0, 2, false, var::column_type::public_input), var(0, 3, false, var::column_type::public_input)}};
 
-    auto result_check = [&expected_res](AssignmentType &assignment, 
+    auto result_check = [&expected_res, public_input](AssignmentType &assignment, 
         typename component_type::result_type &real_res) {
+        #ifdef BLUEPRINT_PLONK_PROFILING_ENABLED
+        std::cout << "unified_addition test: " << "\n";
+        std::cout << "input   : " << public_input[0].data << " " << public_input[1].data << "\n"; 
+        std::cout << "input   : " << public_input[2].data << " " << public_input[3].data << "\n"; 
+        std::cout << "expected: " << expected_res.X.data << " " << expected_res.Y.data << "\n";
+        std::cout << "real    : " << var_value(assignment, real_res.X).data << " " << var_value(assignment, real_res.Y).data << "\n\n";
+        #endif
         assert(expected_res.X == var_value(assignment, real_res.X));
         assert(expected_res.Y == var_value(assignment, real_res.Y));
     };
@@ -82,48 +91,105 @@ void test_unified_addition(std::vector<typename CurveType::base_field_type::valu
         component_instance, public_input, result_check, instance_input);
 }
 
-BOOST_AUTO_TEST_SUITE(blueprint_plonk_test_suite)
+template<typename CurveType>
+void test_unified_addition_with_zeroes() {
+    nil::crypto3::random::algebraic_engine<typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>> generate_random_point;
+    boost::random::mt19937 seed_seq;
+    generate_random_point.seed(seed_seq);
 
-BOOST_AUTO_TEST_CASE(blueprint_plonk_unified_addition_double) {
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type zero_algebraic = {0, 1};
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type zero_circuits  = {0, 0};
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type P = generate_random_point();
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type Q = -P;
 
-    using curve_type = crypto3::algebra::curves::pallas;
+    std::vector<typename CurveType::base_field_type::value_type> public_input;
+
+    public_input = {zero_circuits.X, zero_circuits.Y, zero_circuits.X, zero_circuits.Y};
+    test_unified_addition<CurveType>(public_input, zero_circuits);
+
+    public_input = {zero_circuits.X, zero_circuits.Y, P.X, P.Y};
+    test_unified_addition<CurveType>(public_input, P);
 
-    auto P = crypto3::algebra::random_element<curve_type::template g1_type<>>().to_affine();
-    auto Q(P);
+    public_input = {P.X, P.Y, zero_circuits.X, zero_circuits.Y};
+    test_unified_addition<CurveType>(public_input, P);
 
-    std::vector<typename curve_type::base_field_type::value_type> public_input = {P.X, P.Y, Q.X, Q.Y};
-    typename curve_type::template g1_type<crypto3::algebra::curves::coordinates::affine>::value_type expected_res = P + Q;
+    public_input = {P.X, P.Y, Q.X, Q.Y};
+    test_unified_addition<CurveType>(public_input, zero_circuits);
 
-    test_unified_addition<curve_type>(public_input, expected_res);
+    public_input = {Q.X, Q.Y, P.X, P.Y};
+    test_unified_addition<CurveType>(public_input, zero_circuits);
 }
 
-BOOST_AUTO_TEST_CASE(blueprint_plonk_unified_addition_addition) {
+template<typename CurveType>
+void test_unified_addition_doubling() {
+    nil::crypto3::random::algebraic_engine<typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>> generate_random_point;
+    boost::random::mt19937 seed_seq;
+    generate_random_point.seed(seed_seq);
 
-    using curve_type = crypto3::algebra::curves::pallas;
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type P = generate_random_point();
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type Q(P);
+
+    std::vector<typename CurveType::base_field_type::value_type> public_input;
+
+    public_input = {P.X, P.Y, Q.X, Q.Y};
+    test_unified_addition<CurveType>(public_input, P+Q);
+
+    public_input = {Q.X, Q.Y, P.X, P.Y};
+    test_unified_addition<CurveType>(public_input, P+Q);
+}
 
-    auto P = crypto3::algebra::random_element<curve_type::template g1_type<>>().to_affine();
-    auto Q = crypto3::algebra::random_element<curve_type::template g1_type<>>().to_affine();
-    typename curve_type::template g1_type<crypto3::algebra::curves::coordinates::affine>::value_type zero = {0, 0};
-    typename curve_type::template g1_type<crypto3::algebra::curves::coordinates::affine>::value_type expected_res;
-    P.X = Q.X;
-    P.Y = -Q.Y;
-    if (Q.X == zero.X && Q.Y == zero.Y) {
-        expected_res = P;
-    } else {
-        if (P.X == zero.X && P.Y == zero.Y) {
-            expected_res = Q;
+template<typename CurveType, std::size_t RandomTestsAmount>
+void test_unified_addition_random_data() {
+    nil::crypto3::random::algebraic_engine<typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>> generate_random_point;
+    boost::random::mt19937 seed_seq;
+    generate_random_point.seed(seed_seq);
+
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type P = generate_random_point();
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type Q = generate_random_point();
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type zero = {0, 0};
+    typename CurveType::template g1_type<nil::crypto3::algebra::curves::coordinates::affine>::value_type expected_res;
+
+    std::vector<typename CurveType::base_field_type::value_type> public_input;
+
+    for (std::size_t i = 0; i < RandomTestsAmount; i++){
+        P = generate_random_point();
+        Q = generate_random_point();
+        
+        if (Q.X == zero.X && Q.Y == zero.Y) {
+            expected_res = P;
         } else {
-            if (P.X == Q.X && P.Y == -Q.Y) {
-                expected_res = {0, 0};
+            if (P.X == zero.X && P.Y == zero.Y) {
+                expected_res = Q;
             } else {
-                expected_res = P + Q;
+                if (P.X == Q.X && P.Y == -Q.Y) {
+                    expected_res = {0, 0};
+                } else {
+                    expected_res = P + Q;
+                }
             }
         }
+
+        public_input = {P.X, P.Y, Q.X, Q.Y};
+        test_unified_addition<CurveType>(public_input, expected_res);
     }
+}
+
+constexpr static const std::size_t random_tests_amount = 10;
 
-    std::vector<typename curve_type::base_field_type::value_type> public_input = {P.X, P.Y, Q.X, Q.Y};
+BOOST_AUTO_TEST_SUITE(blueprint_plonk_test_suite)
+
+BOOST_AUTO_TEST_CASE(blueprint_plonk_unified_addition_pallas) {
+    using curve_type = crypto3::algebra::curves::pallas;
+    test_unified_addition_with_zeroes<curve_type>();
+    test_unified_addition_doubling<curve_type>();
+    test_unified_addition_random_data<curve_type, random_tests_amount>();
+}
 
-    test_unified_addition<curve_type>(public_input, expected_res);
+BOOST_AUTO_TEST_CASE(blueprint_plonk_unified_addition_vesta) {
+    using curve_type = crypto3::algebra::curves::vesta;
+    test_unified_addition_with_zeroes<curve_type>();
+    test_unified_addition_doubling<curve_type>();
+    test_unified_addition_random_data<curve_type, random_tests_amount>();
 }
 
 BOOST_AUTO_TEST_SUITE_END()