Fixing usage of constructor of fri_params.

libs/marshalling/zk/test/fri_commitment.cpp

@@ -380,8 +380,11 @@ BOOST_FIXTURE_TEST_SUITE(marshalling_fri_proof_elements, zk::test_tools::random_
         batch_info[3] = 6;
         batch_info[4] = 3;
 
-        typename FRI::params_type fri_params (
-            1, 11, lambda, 4
+        typename FRI::params_type fri_params(
+            1, // max_step
+            11, // degree_log
+            lambda,
+            4 // expand_factor
         );
 
         auto proof = generate_random_fri_proof<FRI>(
@@ -444,42 +447,33 @@ BOOST_AUTO_TEST_CASE(marshalling_fri_basic_test) {
     typedef typename fri_type::proof_type proof_type;
     typedef typename fri_type::params_type params_type;
 
-    std::size_t extended_log = boost::static_log2<d>::value;
-    std::vector<std::shared_ptr<math::evaluation_domain<field_type>>> D =
-            math::calculate_domain_set<field_type>(extended_log, r);
-
-    params_type params(
-        d - 1, // max_degree
-        D,
-        generate_random_step_list(r, 3, generic_random_engine),
-        2, //expand_factor
-        lambda
-    );
-
-    BOOST_CHECK(D[1]->m == D[0]->m / 2);
-    BOOST_CHECK(D[1]->get_domain_element(1) == D[0]->get_domain_element(1).squared());
+    // Setup params
+    std::size_t degree_log = std::ceil(std::log2(d - 1));
+    typename fri_type::params_type fri_params(
+            3, /*max_step*/
+            degree_log,
+            lambda,
+            2 //expand_factor
+            );
 
     // commit
-    math::polynomial<typename field_type::value_type> f = {{1u, 3u, 4u, 1u, 5u, 6u, 7u, 2u, 8u, 7u, 5u, 6u, 1u, 2u, 1u, 1u}};
+    math::polynomial<typename field_type::value_type> f = {{
+        1u, 3u, 4u, 1u, 5u, 6u, 7u, 2u, 8u, 7u, 5u, 6u, 1u, 2u, 1u, 1u}};
     std::array<std::vector<math::polynomial<typename field_type::value_type>>, 1> fs;
     fs[0].resize(1);
     fs[0][0] = f;
-    typename fri_type::merkle_tree_type tree = zk::algorithms::precommit<fri_type>(fs[0], params.D[0],
-                                                                                    params.step_list[0]);
+    typename fri_type::merkle_tree_type tree = zk::algorithms::precommit<fri_type>(
+        fs[0], fri_params.D[0], fri_params.step_list[0]);
     auto root = zk::algorithms::commit<fri_type>(tree);
 
     // eval
     std::vector<std::uint8_t> init_blob{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
     zk::transcript::fiat_shamir_heuristic_sequential<transcript_hash_type> transcript(init_blob);
 
-    proof_type proof = zk::algorithms::proof_eval<fri_type>(f, tree, params, transcript);
+    proof_type proof = zk::algorithms::proof_eval<fri_type>(f, tree, fri_params, transcript);
     nil::crypto3::marshalling::types::batch_info_type batch_info;
     batch_info[0] = 1;
-    test_fri_proof<Endianness, fri_type>(proof, batch_info, params);
-
-    // verify
-    //zk::transcript::fiat_shamir_heuristic_sequential<transcript_hash_type> transcript_verifier(init_blob);
-
-    //BOOST_CHECK(zk::algorithms::verify_eval<fri_type>(proof, root, params, transcript_verifier));
+    test_fri_proof<Endianness, fri_type>(proof, batch_info, fri_params);
 }
+
 BOOST_AUTO_TEST_SUITE_END()

libs/marshalling/zk/test/placeholder_proof.cpp

@@ -323,7 +323,12 @@ BOOST_FIXTURE_TEST_CASE(proof_marshalling_test, test_tools::random_test_initiali
     typename policy_type::variable_assignment_type assignments = circuit.table;
 
     typename lpc_type::fri_type::params_type fri_params(
-        1, table_rows_log, placeholder_test_params::lambda, 4, true, 0xFFFF8000
+        1, /*max_step*/,
+        table_rows_log,
+        placeholder_test_params::lambda,
+        4, // expand_factor
+        true, // use_grinding
+        19 // grinding_parameter
     );
     lpc_scheme_type lpc_scheme(fri_params);
 

libs/zk/include/nil/crypto3/zk/commitments/detail/polynomial/basic_fri.hpp

@@ -144,8 +144,6 @@ namespace nil {
                                 return step_list;
                             }
 
-                            //params_type(const params_type &other){}
-                            // TODO when marshalling will be fine
                             params_type(
                                 std::size_t max_step,
                                 std::size_t degree_log,
@@ -184,37 +182,24 @@ namespace nil {
 
                             bool operator==(const params_type &rhs) const {
                                 if (D.size() != rhs.D.size()) {
-std::cout << "D.size() != rhs.D.size()" << std::endl;
                                     return false;
                                 }
                                 for (std::size_t i = 0; i < D.size(); i++) {
                                     if (D[i]->get_domain_element(1) != rhs.D[i]->get_domain_element(1)) {
-std::cout << "(D[i]->get_domain_element(1) != rhs.D[i]->get_domain_element(1))" << " for " << i << std::endl;
-std::cout << D[i]->get_domain_element(1) << " VS " << rhs.D[i]->get_domain_element(1) << std::endl;
                                         return false;
                                     }
                                 }
                                 if (use_grinding != rhs.use_grinding) {
-std::cout << "use_grinding != rhs.use_grinding" << std::endl;
                                     return false;
                                 }
                                 if (use_grinding && grinding_parameter != rhs.grinding_parameter) {
-std::cout << "use_grinding && grinding_parameter != rhs.grinding_parameter" << std::endl;
                                     return false;
                                 }
-if (r != rhs.r) {
-std::cout << "r != rhs.r" << std::endl;
-}
-
-if (max_degree != rhs.max_degree) {
-std::cout << "max_degree != rhs.max_degree" << std::endl;
-}
                                 return r == rhs.r
                                     && max_degree == rhs.max_degree
                                     && step_list == rhs.step_list
                                     && expand_factor == rhs.expand_factor
-                                    && lambda == rhs.lambda
-                                    && use_grinding == rhs.use_grinding;
+                                    && lambda == rhs.lambda;
                             }
 
                             bool operator!=(const params_type &rhs) const {
@@ -248,8 +233,12 @@ std::cout << "max_degree != rhs.max_degree" << std::endl;
                             }
 
                             // For the last round it's final_polynomial's values
-                            polynomial_values_type               y;                         // Values for the next round.
-                            merkle_proof_type                    p;                         // Merkle proof(values[i-1], T_i)
+
+                            // Values for the next round.
+                            polynomial_values_type y;
+
+                            // Merkle proof(values[i-1], T_i).
+                            merkle_proof_type p;
                         };
 
                         struct initial_proof_type {
@@ -279,6 +268,7 @@ std::cout << "max_degree != rhs.max_degree" << std::endl;
 
                         struct proof_type {
                             bool operator==(const proof_type &rhs) const {
+                                // TODO(martun): check if the following comment can be deleted.
 //                                if( FRI::use_grinding && proof_of_work != rhs.proof_of_work ){
 //                                    return false;
 //                                }

libs/zk/test/commitment/fri.cpp

@@ -108,14 +108,14 @@ void fri_basic_test()
     std::vector<std::shared_ptr<math::evaluation_domain<FieldType>>> D =
         math::calculate_domain_set<FieldType>(extended_log, r);
 
+    std::size_t degree_log = std::ceil(std::log2(d - 1));
     params_type params(
-            d - 1, // max_degree
-            D,
-            generate_random_step_list(r, 1),
-            2, //expand_factor
+            1, /*max_step*/
+            degree_log,
             lambda,
-            true,
-            16
+            2, //expand_factor
+            true, // use_grinding
+            16 // grinding_parameter
             );
 
     BOOST_CHECK(D[1]->m == D[0]->m / 2);

libs/zk/test/commitment/lpc.cpp

@@ -203,15 +203,15 @@ BOOST_AUTO_TEST_SUITE(lpc_math_polynomial_suite);
 
 
         // Setup params
+        std::size_t degree_log = std::ceil(std::log2(d - 1));
         typename fri_type::params_type fri_params(
-                d - 1, // max_degree
-                D,
-                generate_random_step_list(r, 1, test_global_rnd_engine),
-                2, //expand_factor
+                1, /*max_step*/
+                degree_log,
                 lambda,
-                true,
-                12
-        );
+                2, //expand_factor
+                true, // use_grinding
+                12 // grinding_parameter
+                );
 
         using lpc_scheme_type = nil::crypto3::zk::commitments::lpc_commitment_scheme<lpc_type, math::polynomial<typename FieldType::value_type>>;
         lpc_scheme_type lpc_scheme_prover(fri_params);
@@ -304,13 +304,13 @@ BOOST_AUTO_TEST_SUITE(lpc_math_polynomial_suite);
         typedef zk::commitments::fri<FieldType, merkle_hash_type, transcript_hash_type, m> fri_type;
 
         // Setup params
+        std::size_t degree_log = std::ceil(std::log2(d - 1));
         typename fri_type::params_type fri_params(
-                d - 1, // max_degree
-                D,
-                generate_random_step_list(r, 5, test_global_rnd_engine),
-                2, //expand_factor
-                lambda
-        );
+                5, /*max_step*/
+                degree_log,
+                lambda,
+                2 //expand_factor
+                );
 
         using lpc_scheme_type = nil::crypto3::zk::commitments::lpc_commitment_scheme<lpc_type, math::polynomial<typename FieldType::value_type>>;
         lpc_scheme_type lpc_scheme_prover(fri_params);
@@ -396,20 +396,14 @@ BOOST_AUTO_TEST_SUITE(lpc_math_polynomial_suite);
         static_assert(!zk::is_commitment<std::size_t>::value);
 
         // Setup params
-        constexpr static const std::size_t d_extended = d;
-        std::size_t extended_log = boost::static_log2<d_extended>::value;
-        std::vector<std::shared_ptr<math::evaluation_domain<FieldType>>> D =
-                math::calculate_domain_set<FieldType>(extended_log, r + 1);
-
-        // Setup params
+        std::size_t degree_log = std::ceil(std::log2(d - 1));
         typename fri_type::params_type fri_params(
-                d - 1, // max_degree
-                D,
-                generate_random_step_list(r, 1, test_global_rnd_engine),
-                2, //expand_factor
+                1, /*max_step*/
+                degree_log,
                 lambda,
-                true
-        );
+                2, //expand_factor
+                true // use_grinding
+                );
 
         using lpc_scheme_type = nil::crypto3::zk::commitments::lpc_commitment_scheme<lpc_type>;
         lpc_scheme_type lpc_scheme_prover(fri_params);
@@ -498,20 +492,16 @@ BOOST_AUTO_TEST_SUITE(lpc_params_test_suite)
         static_assert(!zk::is_commitment<merkle_tree_type>::value);
         static_assert(!zk::is_commitment<std::size_t>::value);
 
-        constexpr static const std::size_t d_extended = d;
-        std::size_t extended_log = boost::static_log2<d_extended>::value;
-        std::vector<std::shared_ptr<math::evaluation_domain<FieldType>>> D =
-                math::calculate_domain_set<FieldType>(extended_log, r);
-
+        // Setup params
+        std::size_t degree_log = std::ceil(std::log2(d - 1));
         typename fri_type::params_type fri_params(
-                d - 1, // max_degree
-                D,
-                generate_random_step_list(r, 1, test_global_rnd_engine),
-                2,  //expand_factor
+                1, /*max_step*/
+                degree_log,
                 lambda,
-                true,
+                2, // expand_factor
+                true, // use_grinding
                 8
-        );
+                );
 
         using lpc_scheme_type = nil::crypto3::zk::commitments::lpc_commitment_scheme<lpc_type, math::polynomial<typename FieldType::value_type>>;
         lpc_scheme_type lpc_scheme_prover(fri_params);
@@ -595,13 +585,14 @@ BOOST_AUTO_TEST_SUITE(lpc_params_test_suite)
         std::vector<std::shared_ptr<math::evaluation_domain<FieldType>>> D =
                 math::calculate_domain_set<FieldType>(extended_log, r);
 
+        // Setup params
+        std::size_t degree_log = std::ceil(std::log2(d - 1));
         typename fri_type::params_type fri_params(
-                d - 1, // max_degree
-                D,
-                generate_random_step_list(r, 1, test_global_rnd_engine),
-                2, //expand_factor
-                lambda
-        );
+                1, /*max_step*/
+                degree_log,
+                lambda,
+                2 //expand_factor
+                );
 
         using lpc_scheme_type = nil::crypto3::zk::commitments::lpc_commitment_scheme<lpc_type, math::polynomial<typename FieldType::value_type>>;
         lpc_scheme_type lpc_scheme_prover(fri_params);

libs/zk/test/commitment/lpc_performance.cpp

@@ -148,18 +148,14 @@ BOOST_AUTO_TEST_CASE(step_list_1, *boost::unit_test::disabled()) {
     typedef zk::commitments::list_polynomial_commitment_params<merkle_hash_type, transcript_hash_type, m> lpc_params_type;
     typedef zk::commitments::list_polynomial_commitment<FieldType, lpc_params_type> lpc_type;
 
-    constexpr static const std::size_t d_extended = d;
-    std::size_t extended_log = boost::static_log2<d_extended>::value;
-    std::vector<std::shared_ptr<math::evaluation_domain<FieldType>>> D =
-            math::calculate_domain_set<FieldType>(extended_log, r);
-
+    // Setup params
+    std::size_t degree_log = std::ceil(std::log2(d - 1));
     typename fri_type::params_type fri_params(
-            d - 1,
-            D,
-            generate_random_step_list(r, 1),
-            r,
-            lambda
-    );
+            1, /*max_step*/
+            degree_log,
+            lambda,
+            4, //expand_factor
+            );
 
     using lpc_scheme_type = nil::crypto3::zk::commitments::lpc_commitment_scheme<lpc_type, math::polynomial<typename FieldType::value_type>>;
     lpc_scheme_type lpc_scheme_prover(fri_params);
@@ -239,18 +235,14 @@ BOOST_AUTO_TEST_CASE(step_list_3, *boost::unit_test::disabled()) {
     typedef zk::commitments::list_polynomial_commitment_params<merkle_hash_type, transcript_hash_type, m> lpc_params_type;
     typedef zk::commitments::list_polynomial_commitment<FieldType, lpc_params_type> lpc_type;
 
-    constexpr static const std::size_t d_extended = d;
-    std::size_t extended_log = boost::static_log2<d_extended>::value;
-    std::vector<std::shared_ptr<math::evaluation_domain<FieldType>>> D =
-            math::calculate_domain_set<FieldType>(extended_log, r);
-
+    // Setup params
+    std::size_t degree_log = std::ceil(std::log2(d - 1));
     typename fri_type::params_type fri_params(
-            d - 1,
-            D,
-            generate_random_step_list(r, 3),
-            r,
-            lambda
-    );
+            3, /*max_step*/
+            degree_log,
+            lambda,
+            4, //expand_factor
+            );
 
     using lpc_scheme_type = nil::crypto3::zk::commitments::lpc_commitment_scheme<lpc_type, math::polynomial<typename FieldType::value_type>>;
     lpc_scheme_type lpc_scheme_prover(fri_params);
@@ -329,18 +321,14 @@ BOOST_AUTO_TEST_CASE(step_list_5, *boost::unit_test::disabled()) {
     typedef zk::commitments::list_polynomial_commitment_params<merkle_hash_type, transcript_hash_type, m> lpc_params_type;
     typedef zk::commitments::list_polynomial_commitment<FieldType, lpc_params_type> lpc_type;
 
-    constexpr static const std::size_t d_extended = d;
-    std::size_t extended_log = boost::static_log2<d_extended>::value;
-    std::vector<std::shared_ptr<math::evaluation_domain<FieldType>>> D =
-            math::calculate_domain_set<FieldType>(extended_log, r);
-
+    // Setup params
+    std::size_t degree_log = std::ceil(std::log2(d - 1));
     typename fri_type::params_type fri_params(
-            d - 1,
-            D,
-            generate_random_step_list(r, 5),
-            r,
-            lambda
-    );
+            5, /*max_step*/
+            degree_log,
+            lambda,
+            4, //expand_factor
+            );
 
     using lpc_scheme_type = nil::crypto3::zk::commitments::lpc_commitment_scheme<lpc_type, math::polynomial<typename FieldType::value_type>>;
     lpc_scheme_type lpc_scheme_prover(fri_params);