From 7a44b6a107ef4a2387ffc49048accb323654a9f8 Mon Sep 17 00:00:00 2001 From: Iluvmagick Date: Tue, 20 Feb 2024 02:52:32 +0400 Subject: [PATCH] Updated bls for new interfraces. --- .github/workflows/run_tests.yml | 2 + .../detail/plonk/bls12_g2_point_addition.hpp | 76 +++++++++--------- .../detail/plonk/bls12_g2_point_double.hpp | 77 +++++++++---------- .../plonk/non_native/fp12_frobenius_map.hpp | 75 +++++++++--------- .../plonk/non_native/fp12_inversion.hpp | 75 +++++++++--------- .../plonk/non_native/fp12_multiplication.hpp | 73 +++++++++--------- .../plonk/non_native/fp12_small_power.hpp | 73 +++++++++--------- .../weierstrass/plonk/detail/fp12_power_t.hpp | 73 +++++++++--------- test/algebra/curves/plonk/bls12_g2.cpp | 50 ++++++------ .../plonk/non_native/fp12_arithmetic.cpp | 69 +++++++++-------- 10 files changed, 311 insertions(+), 332 deletions(-) diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml index a81b58081..adc802716 100644 --- a/.github/workflows/run_tests.yml +++ b/.github/workflows/run_tests.yml @@ -78,6 +78,8 @@ jobs: blueprint_verifiers_placeholder_f1_loop_test, blueprint_verifiers_placeholder_f3_loop_test, blueprint_verifiers_placeholder_gate_component_test, + blueprint_algebra_curves_plonk_bls12_g2_test, + blueprint_algebra_fields_plonk_non_native_fp12_arithmetic_test, blueprint_proxy_test blueprint_mock_mocked_components_test ] # Tests to execute diff --git a/include/nil/blueprint/components/algebra/curves/detail/plonk/bls12_g2_point_addition.hpp b/include/nil/blueprint/components/algebra/curves/detail/plonk/bls12_g2_point_addition.hpp index b09252280..de795313e 100644 --- a/include/nil/blueprint/components/algebra/curves/detail/plonk/bls12_g2_point_addition.hpp +++ b/include/nil/blueprint/components/algebra/curves/detail/plonk/bls12_g2_point_addition.hpp @@ -29,6 +29,8 @@ #ifndef CRYPTO3_BLUEPRINT_COMPONENTS_PLONK_BLS12_G2_POINT_ADDITION_HPP #define CRYPTO3_BLUEPRINT_COMPONENTS_PLONK_BLS12_G2_POINT_ADDITION_HPP +#include + #include #include @@ -58,16 +60,15 @@ namespace nil { // +--+--+--+--+--+--+---+---+--+--+--+--+ // - template + template class bls12_g2_point_addition; - template - class bls12_g2_point_addition, - BlueprintFieldType> - : public plonk_component { + template + class bls12_g2_point_addition> + : public plonk_component { public: - using component_type = plonk_component; + using component_type = plonk_component; using var = typename component_type::var; using manifest_type = plonk_component_manifest; @@ -104,8 +105,8 @@ namespace nil { struct input_type { std::array P, Q; - std::vector all_vars() const { - std::vector res = {}; + std::vector> all_vars() { + std::vector> res = {}; for(auto & e : P) { res.push_back(e); } for(auto & e : Q) { res.push_back(e); } return res; @@ -150,23 +151,20 @@ namespace nil { component_type(witnesses, constants, public_inputs, get_manifest()) {}; }; - template + template using plonk_bls12_g2_point_addition = bls12_g2_point_addition< - crypto3::zk::snark::plonk_constraint_system, - BlueprintFieldType>; + crypto3::zk::snark::plonk_constraint_system>; - template - typename plonk_bls12_g2_point_addition::result_type generate_assignments( - const plonk_bls12_g2_point_addition &component, - assignment> + template + typename plonk_bls12_g2_point_addition::result_type generate_assignments( + const plonk_bls12_g2_point_addition &component, + assignment> &assignment, - const typename plonk_bls12_g2_point_addition::input_type + const typename plonk_bls12_g2_point_addition::input_type &instance_input, const std::uint32_t start_row_index) { - using value_type = typename BlueprintFieldType::value_type; - const std::size_t WA = component.witness_amount(); using policy_type_fp2 = crypto3::algebra::fields::fp2; @@ -222,22 +220,22 @@ namespace nil { assignment.witness(component.W((22 + i) % WA),start_row_index + (WA < 24)) = yR.data[i]; } - return typename plonk_bls12_g2_point_addition::result_type( + return typename plonk_bls12_g2_point_addition::result_type( component, start_row_index); } - template + template std::size_t generate_gates( - const plonk_bls12_g2_point_addition &component, - circuit> &bp, - assignment> + const plonk_bls12_g2_point_addition &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_bls12_g2_point_addition::input_type + const typename plonk_bls12_g2_point_addition::input_type &instance_input) { const std::size_t WA = component.witness_amount(); - using var = typename plonk_bls12_g2_point_addition::var; + using var = typename plonk_bls12_g2_point_addition::var; using constraint_type = crypto3::zk::snark::plonk_constraint; // Fp2 field over constraints: @@ -325,31 +323,29 @@ namespace nil { return bp.add_gate(Cs); } - template + template void generate_copy_constraints( - const plonk_bls12_g2_point_addition &component, - circuit> &bp, - assignment> + const plonk_bls12_g2_point_addition &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_bls12_g2_point_addition::input_type &instance_input, + const typename plonk_bls12_g2_point_addition::input_type &instance_input, const std::size_t start_row_index) { - using var = typename plonk_bls12_g2_point_addition::var; - - const std::size_t WA = component.witness_amount(); + using var = typename plonk_bls12_g2_point_addition::var; for(std::size_t i = 0; i < 4; i++) { bp.add_copy_constraint({var(component.W(i), start_row_index, false), instance_input.P[i]}); } } - template - typename plonk_bls12_g2_point_addition::result_type generate_circuit( - const plonk_bls12_g2_point_addition &component, - circuit> &bp, - assignment> + template + typename plonk_bls12_g2_point_addition::result_type generate_circuit( + const plonk_bls12_g2_point_addition &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_bls12_g2_point_addition::input_type &instance_input, + const typename plonk_bls12_g2_point_addition::input_type &instance_input, const std::size_t start_row_index) { std::size_t selector_index = generate_gates(component, bp, assignment, instance_input); @@ -358,7 +354,7 @@ namespace nil { generate_copy_constraints(component, bp, assignment, instance_input, start_row_index); - return typename plonk_bls12_g2_point_addition::result_type( + return typename plonk_bls12_g2_point_addition::result_type( component, start_row_index); } diff --git a/include/nil/blueprint/components/algebra/curves/detail/plonk/bls12_g2_point_double.hpp b/include/nil/blueprint/components/algebra/curves/detail/plonk/bls12_g2_point_double.hpp index c2ffd0f0f..b9548507d 100644 --- a/include/nil/blueprint/components/algebra/curves/detail/plonk/bls12_g2_point_double.hpp +++ b/include/nil/blueprint/components/algebra/curves/detail/plonk/bls12_g2_point_double.hpp @@ -49,16 +49,15 @@ namespace nil { // Input: (xP, yP) = P[4] // Output: (xR, yR) = R[4], R = [2]P as element of E'(F_p^2) - template + template class bls12_g2_point_double; - template - class bls12_g2_point_double, - BlueprintFieldType> - : public plonk_component { + template + class bls12_g2_point_double> + : public plonk_component { public: - using component_type = plonk_component; + using component_type = plonk_component; using var = typename component_type::var; using manifest_type = plonk_component_manifest; @@ -95,8 +94,8 @@ namespace nil { struct input_type { std::array P; - std::vector all_vars() const { - std::vector res = {}; + std::vector> all_vars() { + std::vector> res = {}; for(auto & e : P) { res.push_back(e); } return res; } @@ -138,23 +137,19 @@ namespace nil { component_type(witnesses, constants, public_inputs, get_manifest()) {}; }; - template + template using plonk_bls12_g2_point_double = - bls12_g2_point_double< - crypto3::zk::snark::plonk_constraint_system, - BlueprintFieldType>; - - template - typename plonk_bls12_g2_point_double::result_type generate_assignments( - const plonk_bls12_g2_point_double &component, - assignment> + bls12_g2_point_double>; + + template + typename plonk_bls12_g2_point_double::result_type generate_assignments( + const plonk_bls12_g2_point_double &component, + assignment> &assignment, - const typename plonk_bls12_g2_point_double::input_type + const typename plonk_bls12_g2_point_double::input_type &instance_input, const std::uint32_t start_row_index) { - using value_type = typename BlueprintFieldType::value_type; - using policy_type_fp2 = crypto3::algebra::fields::fp2; using fp2_element = typename policy_type_fp2::value_type; @@ -176,20 +171,20 @@ namespace nil { assignment.witness(component.W(8 + i),start_row_index) = yR.data[i]; } - return typename plonk_bls12_g2_point_double::result_type( + return typename plonk_bls12_g2_point_double::result_type( component, start_row_index); } - template + template std::size_t generate_gates( - const plonk_bls12_g2_point_double &component, - circuit> &bp, - assignment> + const plonk_bls12_g2_point_double &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_bls12_g2_point_double::input_type + const typename plonk_bls12_g2_point_double::input_type &instance_input) { - using var = typename plonk_bls12_g2_point_double::var; + using var = typename plonk_bls12_g2_point_double::var; using constraint_type = crypto3::zk::snark::plonk_constraint; using fp2_constraint = detail::abstract_fp2_element; @@ -233,31 +228,29 @@ namespace nil { return bp.add_gate(Cs); } - template + template void generate_copy_constraints( - const plonk_bls12_g2_point_double &component, - circuit> &bp, - assignment> + const plonk_bls12_g2_point_double &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_bls12_g2_point_double::input_type &instance_input, + const typename plonk_bls12_g2_point_double::input_type &instance_input, const std::size_t start_row_index) { - using var = typename plonk_bls12_g2_point_double::var; - - const std::size_t WA = component.witness_amount(); + using var = typename plonk_bls12_g2_point_double::var; for(std::size_t i = 0; i < 4; i++) { bp.add_copy_constraint({var(component.W(i), start_row_index, false), instance_input.P[i]}); } } - template - typename plonk_bls12_g2_point_double::result_type generate_circuit( - const plonk_bls12_g2_point_double &component, - circuit> &bp, - assignment> + template + typename plonk_bls12_g2_point_double::result_type generate_circuit( + const plonk_bls12_g2_point_double &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_bls12_g2_point_double::input_type &instance_input, + const typename plonk_bls12_g2_point_double::input_type &instance_input, const std::size_t start_row_index) { std::size_t selector_index = generate_gates(component, bp, assignment, instance_input); @@ -266,7 +259,7 @@ namespace nil { generate_copy_constraints(component, bp, assignment, instance_input, start_row_index); - return typename plonk_bls12_g2_point_double::result_type( + return typename plonk_bls12_g2_point_double::result_type( component, start_row_index); } diff --git a/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_frobenius_map.hpp b/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_frobenius_map.hpp index 3ef07c2de..ee186d92e 100644 --- a/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_frobenius_map.hpp +++ b/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_frobenius_map.hpp @@ -146,16 +146,15 @@ namespace nil { using namespace detail; - template + template class fp12_frobenius_map; - template - class fp12_frobenius_map, - BlueprintFieldType, Power> - : public plonk_component { + template + class fp12_frobenius_map, Power> + : public plonk_component { public: - using component_type = plonk_component; + using component_type = plonk_component; using var = typename component_type::var; using manifest_type = plonk_component_manifest; @@ -192,8 +191,8 @@ namespace nil { struct input_type { std::array x; - std::vector all_vars() const { - std::vector res = {}; + std::vector> all_vars() { + std::vector> res = {}; for(auto & e : x) { res.push_back(e); } return res; } @@ -237,18 +236,16 @@ namespace nil { component_type(witnesses, constants, public_inputs, get_manifest()) {}; }; - template + template using plonk_fp12_frobenius_map = - fp12_frobenius_map< - crypto3::zk::snark::plonk_constraint_system, - BlueprintFieldType, Power>; - - template - typename plonk_fp12_frobenius_map::result_type generate_assignments( - const plonk_fp12_frobenius_map &component, - assignment> + fp12_frobenius_map, Power>; + + template + typename plonk_fp12_frobenius_map::result_type generate_assignments( + const plonk_fp12_frobenius_map &component, + assignment> &assignment, - const typename plonk_fp12_frobenius_map::input_type + const typename plonk_fp12_frobenius_map::input_type &instance_input, const std::uint32_t start_row_index) { @@ -278,20 +275,20 @@ namespace nil { assignment.witness(component.W((12 + i) % WA),start_row_index + (12 + i)/WA) = Y.data[i/6].data[(i % 6)/2].data[i % 2]; } - return typename plonk_fp12_frobenius_map::result_type( + return typename plonk_fp12_frobenius_map::result_type( component, start_row_index); } - template + template std::size_t generate_gates( - const plonk_fp12_frobenius_map &component, - circuit> &bp, - assignment> + const plonk_fp12_frobenius_map &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_frobenius_map::input_type + const typename plonk_fp12_frobenius_map::input_type &instance_input) { - using var = typename plonk_fp12_frobenius_map::var; + using var = typename plonk_fp12_frobenius_map::var; using constraint_type = crypto3::zk::snark::plonk_constraint; const std::size_t WA = component.witness_amount(); @@ -325,31 +322,29 @@ namespace nil { return bp.add_gate(Cs); } - template + template void generate_copy_constraints( - const plonk_fp12_frobenius_map &component, - circuit> &bp, - assignment> + const plonk_fp12_frobenius_map &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_frobenius_map::input_type &instance_input, + const typename plonk_fp12_frobenius_map::input_type &instance_input, const std::size_t start_row_index) { - using var = typename plonk_fp12_frobenius_map::var; - - const std::size_t WA = component.witness_amount(); + using var = typename plonk_fp12_frobenius_map::var; for(std::size_t i = 0; i < 12; i++) { bp.add_copy_constraint({var(component.W(i), start_row_index, false), instance_input.x[i]}); } } - template - typename plonk_fp12_frobenius_map::result_type generate_circuit( - const plonk_fp12_frobenius_map &component, - circuit> &bp, - assignment> + template + typename plonk_fp12_frobenius_map::result_type generate_circuit( + const plonk_fp12_frobenius_map &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_frobenius_map::input_type &instance_input, + const typename plonk_fp12_frobenius_map::input_type &instance_input, const std::size_t start_row_index) { std::size_t selector_index = generate_gates(component, bp, assignment, instance_input); @@ -358,7 +353,7 @@ namespace nil { generate_copy_constraints(component, bp, assignment, instance_input, start_row_index); - return typename plonk_fp12_frobenius_map::result_type( + return typename plonk_fp12_frobenius_map::result_type( component, start_row_index); } } // namespace components diff --git a/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_inversion.hpp b/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_inversion.hpp index 5d2012218..cf05e7f51 100644 --- a/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_inversion.hpp +++ b/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_inversion.hpp @@ -50,16 +50,15 @@ namespace nil { // Input: x[12], x != 0 // Output: y[12]: x*y = 1 as elements of F_p^12 - template + template class fp12_inversion; - template - class fp12_inversion, - BlueprintFieldType> - : public plonk_component { + template + class fp12_inversion> + : public plonk_component { public: - using component_type = plonk_component; + using component_type = plonk_component; using var = typename component_type::var; using manifest_type = plonk_component_manifest; @@ -96,8 +95,8 @@ namespace nil { struct input_type { std::array x; - std::vector all_vars() const { - std::vector res = {}; + std::vector> all_vars() { + std::vector> res = {}; for(auto & e : x) { res.push_back(e); } return res; } @@ -141,18 +140,16 @@ namespace nil { component_type(witnesses, constants, public_inputs, get_manifest()) {}; }; - template + template using plonk_fp12_inversion = - fp12_inversion< - crypto3::zk::snark::plonk_constraint_system, - BlueprintFieldType>; - - template - typename plonk_fp12_inversion::result_type generate_assignments( - const plonk_fp12_inversion &component, - assignment> + fp12_inversion>; + + template + typename plonk_fp12_inversion::result_type generate_assignments( + const plonk_fp12_inversion &component, + assignment> &assignment, - const typename plonk_fp12_inversion::input_type + const typename plonk_fp12_inversion::input_type &instance_input, const std::uint32_t start_row_index) { @@ -177,20 +174,20 @@ namespace nil { assignment.witness(component.W((12 + i) % WA),start_row_index + (12 + i)/WA) = Y.data[i/6].data[(i % 6)/2].data[i % 2]; } - return typename plonk_fp12_inversion::result_type( + return typename plonk_fp12_inversion::result_type( component, start_row_index); } - template + template std::size_t generate_gates( - const plonk_fp12_inversion &component, - circuit> &bp, - assignment> + const plonk_fp12_inversion &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_inversion::input_type + const typename plonk_fp12_inversion::input_type &instance_input) { - using var = typename plonk_fp12_inversion::var; + using var = typename plonk_fp12_inversion::var; using constraint_type = crypto3::zk::snark::plonk_constraint; using fp12_constraint = detail::abstract_fp12_element; @@ -213,31 +210,29 @@ namespace nil { return bp.add_gate(Cs); } - template + template void generate_copy_constraints( - const plonk_fp12_inversion &component, - circuit> &bp, - assignment> + const plonk_fp12_inversion &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_inversion::input_type &instance_input, + const typename plonk_fp12_inversion::input_type &instance_input, const std::size_t start_row_index) { - using var = typename plonk_fp12_inversion::var; - - const std::size_t WA = component.witness_amount(); + using var = typename plonk_fp12_inversion::var; for(std::size_t i = 0; i < 12; i++) { bp.add_copy_constraint({var(component.W(i), start_row_index, false), instance_input.x[i]}); } } - template - typename plonk_fp12_inversion::result_type generate_circuit( - const plonk_fp12_inversion &component, - circuit> &bp, - assignment> + template + typename plonk_fp12_inversion::result_type generate_circuit( + const plonk_fp12_inversion &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_inversion::input_type &instance_input, + const typename plonk_fp12_inversion::input_type &instance_input, const std::size_t start_row_index) { std::size_t selector_index = generate_gates(component, bp, assignment, instance_input); @@ -246,7 +241,7 @@ namespace nil { generate_copy_constraints(component, bp, assignment, instance_input, start_row_index); - return typename plonk_fp12_inversion::result_type( + return typename plonk_fp12_inversion::result_type( component, start_row_index); } diff --git a/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_multiplication.hpp b/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_multiplication.hpp index a9daa4b92..2d9339658 100644 --- a/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_multiplication.hpp +++ b/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_multiplication.hpp @@ -47,16 +47,15 @@ namespace nil { // Input: a[12], b[12] // Output: c[12] = a*b as elements of F_p^12 - template + template class fp12_multiplication; - template - class fp12_multiplication, - BlueprintFieldType> - : public plonk_component { + template + class fp12_multiplication> + : public plonk_component { public: - using component_type = plonk_component; + using component_type = plonk_component; using var = typename component_type::var; using manifest_type = plonk_component_manifest; @@ -94,8 +93,8 @@ namespace nil { std::array a; std::array b; - std::vector all_vars() const { - std::vector res = {}; + std::vector> all_vars() { + std::vector> res = {}; for(auto & e : a) { res.push_back(e); } for(auto & e : b) { res.push_back(e); } return res; @@ -140,18 +139,16 @@ namespace nil { component_type(witnesses, constants, public_inputs, get_manifest()) {}; }; - template + template using plonk_fp12_multiplication = - fp12_multiplication< - crypto3::zk::snark::plonk_constraint_system, - BlueprintFieldType>; - - template - typename plonk_fp12_multiplication::result_type generate_assignments( - const plonk_fp12_multiplication &component, - assignment> + fp12_multiplication>; + + template + typename plonk_fp12_multiplication::result_type generate_assignments( + const plonk_fp12_multiplication &component, + assignment> &assignment, - const typename plonk_fp12_multiplication::input_type + const typename plonk_fp12_multiplication::input_type &instance_input, const std::uint32_t start_row_index) { @@ -180,20 +177,20 @@ namespace nil { assignment.witness(component.W((24 + i) % WA),start_row_index + (24 + i)/WA) = C.data[i/6].data[(i % 6)/2].data[i % 2]; } - return typename plonk_fp12_multiplication::result_type( + return typename plonk_fp12_multiplication::result_type( component, start_row_index); } - template + template std::size_t generate_gates( - const plonk_fp12_multiplication &component, - circuit> &bp, - assignment> + const plonk_fp12_multiplication &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_multiplication::input_type + const typename plonk_fp12_multiplication::input_type &instance_input) { - using var = typename plonk_fp12_multiplication::var; + using var = typename plonk_fp12_multiplication::var; using constraint_type = crypto3::zk::snark::plonk_constraint; using fp12_constraint = detail::abstract_fp12_element; @@ -217,16 +214,16 @@ namespace nil { return bp.add_gate(Cs); } - template + template void generate_copy_constraints( - const plonk_fp12_multiplication &component, - circuit> &bp, - assignment> + const plonk_fp12_multiplication &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_multiplication::input_type &instance_input, + const typename plonk_fp12_multiplication::input_type &instance_input, const std::size_t start_row_index) { - using var = typename plonk_fp12_multiplication::var; + using var = typename plonk_fp12_multiplication::var; const std::size_t WA = component.witness_amount(); @@ -236,13 +233,13 @@ namespace nil { } } - template - typename plonk_fp12_multiplication::result_type generate_circuit( - const plonk_fp12_multiplication &component, - circuit> &bp, - assignment> + template + typename plonk_fp12_multiplication::result_type generate_circuit( + const plonk_fp12_multiplication &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_multiplication::input_type &instance_input, + const typename plonk_fp12_multiplication::input_type &instance_input, const std::size_t start_row_index) { std::size_t selector_index = generate_gates(component, bp, assignment, instance_input); @@ -252,7 +249,7 @@ namespace nil { generate_copy_constraints(component, bp, assignment, instance_input, start_row_index); - return typename plonk_fp12_multiplication::result_type( + return typename plonk_fp12_multiplication::result_type( component, start_row_index); } diff --git a/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_small_power.hpp b/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_small_power.hpp index d561e1a15..ba39240ed 100644 --- a/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_small_power.hpp +++ b/include/nil/blueprint/components/algebra/fields/plonk/non_native/fp12_small_power.hpp @@ -32,6 +32,7 @@ #ifndef CRYPTO3_BLUEPRINT_COMPONENTS_PLONK_FP12_SMALL_POWER_HPP #define CRYPTO3_BLUEPRINT_COMPONENTS_PLONK_FP12_SMALL_POWER_HPP +#include #include #include @@ -58,16 +59,15 @@ namespace nil { using namespace detail; - template + template class fp12_small_power; - template - class fp12_small_power, - BlueprintFieldType, Power> - : public plonk_component { + template + class fp12_small_power, Power> + : public plonk_component { public: - using component_type = plonk_component; + using component_type = plonk_component; using var = typename component_type::var; using manifest_type = plonk_component_manifest; @@ -104,8 +104,8 @@ namespace nil { struct input_type { std::array x; - std::vector all_vars() const { - std::vector res = {}; + std::vector> all_vars() { + std::vector> res = {}; for(auto & e : x) { res.push_back(e); } return res; } @@ -149,18 +149,17 @@ namespace nil { component_type(witnesses, constants, public_inputs, get_manifest()) {}; }; - template + template using plonk_fp12_small_power = fp12_small_power< - crypto3::zk::snark::plonk_constraint_system, - BlueprintFieldType, Power>; + crypto3::zk::snark::plonk_constraint_system, Power>; - template - typename plonk_fp12_small_power::result_type generate_assignments( - const plonk_fp12_small_power &component, - assignment> + template + typename plonk_fp12_small_power::result_type generate_assignments( + const plonk_fp12_small_power &component, + assignment> &assignment, - const typename plonk_fp12_small_power::input_type + const typename plonk_fp12_small_power::input_type &instance_input, const std::uint32_t start_row_index) { @@ -185,20 +184,20 @@ namespace nil { assignment.witness(component.W((12 + i) % WA),start_row_index + (12 + i)/WA) = Y.data[i/6].data[(i % 6)/2].data[i % 2]; } - return typename plonk_fp12_small_power::result_type( + return typename plonk_fp12_small_power::result_type( component, start_row_index); } - template + template std::size_t generate_gates( - const plonk_fp12_small_power &component, - circuit> &bp, - assignment> + const plonk_fp12_small_power &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_small_power::input_type + const typename plonk_fp12_small_power::input_type &instance_input) { - using var = typename plonk_fp12_small_power::var; + using var = typename plonk_fp12_small_power::var; using constraint_type = crypto3::zk::snark::plonk_constraint; using fp12_constraint = detail::abstract_fp12_element; @@ -235,31 +234,29 @@ namespace nil { return bp.add_gate(Cs); } - template + template void generate_copy_constraints( - const plonk_fp12_small_power &component, - circuit> &bp, - assignment> + const plonk_fp12_small_power &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_small_power::input_type &instance_input, + const typename plonk_fp12_small_power::input_type &instance_input, const std::size_t start_row_index) { - using var = typename plonk_fp12_small_power::var; - - const std::size_t WA = component.witness_amount(); + using var = typename plonk_fp12_small_power::var; for(std::size_t i = 0; i < 12; i++) { bp.add_copy_constraint({var(component.W(i), start_row_index, false), instance_input.x[i]}); } } - template - typename plonk_fp12_small_power::result_type generate_circuit( - const plonk_fp12_small_power &component, - circuit> &bp, - assignment> + template + typename plonk_fp12_small_power::result_type generate_circuit( + const plonk_fp12_small_power &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_small_power::input_type &instance_input, + const typename plonk_fp12_small_power::input_type &instance_input, const std::size_t start_row_index) { std::size_t selector_index = generate_gates(component, bp, assignment, instance_input); @@ -268,7 +265,7 @@ namespace nil { generate_copy_constraints(component, bp, assignment, instance_input, start_row_index); - return typename plonk_fp12_small_power::result_type( + return typename plonk_fp12_small_power::result_type( component, start_row_index); } } // namespace components diff --git a/include/nil/blueprint/components/algebra/pairing/weierstrass/plonk/detail/fp12_power_t.hpp b/include/nil/blueprint/components/algebra/pairing/weierstrass/plonk/detail/fp12_power_t.hpp index 931cf2161..407610f6d 100644 --- a/include/nil/blueprint/components/algebra/pairing/weierstrass/plonk/detail/fp12_power_t.hpp +++ b/include/nil/blueprint/components/algebra/pairing/weierstrass/plonk/detail/fp12_power_t.hpp @@ -61,20 +61,19 @@ namespace nil { // writing the value 53760 twice for better alignment of gates. // - template + template class fp12_power_t; - template - class fp12_power_t, - BlueprintFieldType> - : public plonk_component { + template + class fp12_power_t> + : public plonk_component { static std::size_t gates_amount_internal(std::size_t witness_amount) { return (witness_amount == 12) ? 4 : 5; } public: - using component_type = plonk_component; + using component_type = plonk_component; using var = typename component_type::var; using manifest_type = plonk_component_manifest; @@ -120,8 +119,8 @@ namespace nil { struct input_type { std::array x; - std::vector all_vars() const { - std::vector res = {}; + std::vector> all_vars() { + std::vector> res = {}; for(auto & e : x) { res.push_back(e); } return res; } @@ -166,18 +165,16 @@ namespace nil { component_type(witnesses, constants, public_inputs, get_manifest()) {}; }; - template + template using plonk_fp12_power_t = - fp12_power_t< - crypto3::zk::snark::plonk_constraint_system, - BlueprintFieldType>; - - template - typename plonk_fp12_power_t::result_type generate_assignments( - const plonk_fp12_power_t &component, - assignment> + fp12_power_t>; + + template + typename plonk_fp12_power_t::result_type generate_assignments( + const plonk_fp12_power_t &component, + assignment> &assignment, - const typename plonk_fp12_power_t::input_type + const typename plonk_fp12_power_t::input_type &instance_input, const std::uint32_t start_row_index) { @@ -233,20 +230,20 @@ namespace nil { Y = Y.pow(4); fill_slot(Y); // X^{4(1 + 4^16*53761)},...,X^{4^8(1 + 4^16 * 53761)} } - return typename plonk_fp12_power_t::result_type( + return typename plonk_fp12_power_t::result_type( component, start_row_index); } - template + template std::vector generate_gates( - const plonk_fp12_power_t &component, - circuit> &bp, - assignment> + const plonk_fp12_power_t &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_power_t::input_type + const typename plonk_fp12_power_t::input_type &instance_input) { - using var = typename plonk_fp12_power_t::var; + using var = typename plonk_fp12_power_t::var; using constraint_type = crypto3::zk::snark::plonk_constraint; using fp12_constraint = detail::abstract_fp12_element; @@ -325,16 +322,16 @@ namespace nil { return gate_list; } - template + template void generate_copy_constraints( - const plonk_fp12_power_t &component, - circuit> &bp, - assignment> + const plonk_fp12_power_t &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_power_t::input_type &instance_input, + const typename plonk_fp12_power_t::input_type &instance_input, const std::size_t start_row_index) { - using var = typename plonk_fp12_power_t::var; + using var = typename plonk_fp12_power_t::var; const std::size_t WA = component.witness_amount(); std::vector apply_list; @@ -359,13 +356,13 @@ namespace nil { } } - template - typename plonk_fp12_power_t::result_type generate_circuit( - const plonk_fp12_power_t &component, - circuit> &bp, - assignment> + template + typename plonk_fp12_power_t::result_type generate_circuit( + const plonk_fp12_power_t &component, + circuit> &bp, + assignment> &assignment, - const typename plonk_fp12_power_t::input_type &instance_input, + const typename plonk_fp12_power_t::input_type &instance_input, const std::size_t start_row_index) { const std::size_t WA = component.witness_amount(); @@ -427,7 +424,7 @@ namespace nil { generate_copy_constraints(component, bp, assignment, instance_input, start_row_index); - return typename plonk_fp12_power_t::result_type( + return typename plonk_fp12_power_t::result_type( component, start_row_index); } } // namespace components diff --git a/test/algebra/curves/plonk/bls12_g2.cpp b/test/algebra/curves/plonk/bls12_g2.cpp index dde5278df..43125b610 100644 --- a/test/algebra/curves/plonk/bls12_g2.cpp +++ b/test/algebra/curves/plonk/bls12_g2.cpp @@ -50,22 +50,22 @@ void test_bls12_g2_doubling(std::vector::value_type expected_res){ using curve_type = CurveType; - using BlueprintFieldType = typename curve_type::g2_type<>::field_type::base_field_type; + using BlueprintFieldType = typename curve_type::template g2_type<>::field_type::base_field_type; constexpr std::size_t WitnessColumns = 10; constexpr std::size_t PublicInputColumns = 1; constexpr std::size_t ConstantColumns = 0; constexpr std::size_t SelectorColumns = 1; - using ArithmetizationParams = - crypto3::zk::snark::plonk_arithmetization_params; - using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; + zk::snark::plonk_table_description desc( + WitnessColumns, PublicInputColumns, ConstantColumns, SelectorColumns); + using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; using AssignmentType = blueprint::assignment; using hash_type = crypto3::hashes::keccak_1600<256>; constexpr std::size_t Lambda = 40; using var = crypto3::zk::snark::plonk_variable; - using component_type = blueprint::components::bls12_g2_point_double; + using component_type = blueprint::components::bls12_g2_point_double; typename component_type::input_type instance_input = { var(0, 0, false, var::column_type::public_input), var(0, 1, false, var::column_type::public_input), @@ -73,8 +73,9 @@ void test_bls12_g2_doubling(std::vector::field_type::value_type expected_x = expected_res.X / expected_res.Z.pow(2), - expected_y = expected_res.Y / expected_res.Z.pow(3); + typename curve_type::template g2_type<>::field_type::value_type + expected_x = expected_res.X / expected_res.Z.pow(2), + expected_y = expected_res.Y / expected_res.Z.pow(3); #ifdef BLUEPRINT_PLONK_PROFILING_ENABLED std::cout << "G2 doubling test: " << "\n"; std::cout << "input : " << public_input[0].data << "," << public_input[1].data << "\n"; @@ -92,8 +93,8 @@ void test_bls12_g2_doubling(std::vector( - component_instance, public_input, result_check, instance_input); + crypto3::test_component( + component_instance, desc, public_input, result_check, instance_input); } template @@ -101,33 +102,34 @@ void test_bls12_g2_adding(std::vector::value_type expected_res){ using curve_type = CurveType; - using BlueprintFieldType = typename curve_type::g2_type<>::field_type::base_field_type; + using BlueprintFieldType = typename curve_type::template g2_type<>::field_type::base_field_type; constexpr std::size_t WitnessColumns = 12; constexpr std::size_t PublicInputColumns = 1; constexpr std::size_t ConstantColumns = 0; constexpr std::size_t SelectorColumns = 1; - using ArithmetizationParams = - crypto3::zk::snark::plonk_arithmetization_params; - using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; + zk::snark::plonk_table_description desc( + WitnessColumns, PublicInputColumns, ConstantColumns, SelectorColumns); + using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; using AssignmentType = blueprint::assignment; using hash_type = crypto3::hashes::keccak_1600<256>; constexpr std::size_t Lambda = 40; using var = crypto3::zk::snark::plonk_variable; - using component_type = blueprint::components::bls12_g2_point_addition; + using component_type = blueprint::components::bls12_g2_point_addition; typename component_type::input_type instance_input = { - 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), - var(0, 4, false, var::column_type::public_input), var(0, 5, false, var::column_type::public_input), - var(0, 6, false, var::column_type::public_input), var(0, 7, false, var::column_type::public_input)}; + {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)}, + {var(0, 4, false, var::column_type::public_input), var(0, 5, false, var::column_type::public_input), + var(0, 6, false, var::column_type::public_input), var(0, 7, false, var::column_type::public_input)}}; auto result_check = [&expected_res, public_input](AssignmentType &assignment, typename component_type::result_type &real_res) { - typename curve_type::g2_type<>::field_type::value_type expected_x = expected_res.X / expected_res.Z.pow(2), - expected_y = expected_res.Y / expected_res.Z.pow(3); + typename curve_type::template g2_type<>::field_type::value_type + expected_x = expected_res.X / expected_res.Z.pow(2), + expected_y = expected_res.Y / expected_res.Z.pow(3); #ifdef BLUEPRINT_PLONK_PROFILING_ENABLED std::cout << "G2 addition test: " << "\n"; std::cout << "input : " << public_input[0].data << "," << public_input[1].data << "\n"; @@ -147,17 +149,15 @@ void test_bls12_g2_adding(std::vector( - component_instance, public_input, result_check, instance_input); + crypto3::test_component( + component_instance, desc, public_input, result_check, instance_input); } -constexpr static const std::size_t random_tests_amount = 10; - BOOST_AUTO_TEST_SUITE(blueprint_plonk_test_suite) BOOST_AUTO_TEST_CASE(blueprint_plonk_bls12_g2_test_381) { using curve_type = crypto3::algebra::curves::bls12_381; - using group_type = typename curve_type::g2_type<>; + using group_type = typename curve_type::template g2_type<>; using base_field_value = curve_type::base_field_type::value_type; typedef typename group_type::value_type group_value_type; diff --git a/test/algebra/fields/plonk/non_native/fp12_arithmetic.cpp b/test/algebra/fields/plonk/non_native/fp12_arithmetic.cpp index 97e232209..2f83e0c48 100644 --- a/test/algebra/fields/plonk/non_native/fp12_arithmetic.cpp +++ b/test/algebra/fields/plonk/non_native/fp12_arithmetic.cpp @@ -56,9 +56,9 @@ void test_fp12_multiplication(std::vector public constexpr std::size_t ConstantColumns = 0; constexpr std::size_t SelectorColumns = 1; - using ArithmetizationParams = - crypto3::zk::snark::plonk_arithmetization_params; - using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; + zk::snark::plonk_table_description desc( + WitnessColumns, PublicInputColumns, ConstantColumns, SelectorColumns); + using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; using hash_type = nil::crypto3::hashes::keccak_1600<256>; constexpr std::size_t Lambda = 40; using AssignmentType = nil::blueprint::assignment; @@ -66,7 +66,7 @@ void test_fp12_multiplication(std::vector public using value_type = typename FieldType::value_type; using var = crypto3::zk::snark::plonk_variable; - using component_type = blueprint::components::fp12_multiplication; + using component_type = blueprint::components::fp12_multiplication; typename component_type::input_type instance_input; typename std::array A, B; @@ -118,7 +118,9 @@ void test_fp12_multiplication(std::vector public std::array{} // public inputs ); - nil::crypto3::test_component (component_instance, public_input, result_check, instance_input, nil::crypto3::detail::connectedness_check_type::STRONG); + nil::crypto3::test_component ( + component_instance, desc, public_input, result_check, instance_input, + nil::blueprint::connectedness_check_type::type::STRONG); } template @@ -127,9 +129,9 @@ void test_fp12_inversion(std::vector public_inpu constexpr std::size_t ConstantColumns = 0; constexpr std::size_t SelectorColumns = 1; - using ArithmetizationParams = - crypto3::zk::snark::plonk_arithmetization_params; - using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; + zk::snark::plonk_table_description desc( + WitnessColumns, PublicInputColumns, ConstantColumns, SelectorColumns); + using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; using hash_type = nil::crypto3::hashes::keccak_1600<256>; constexpr std::size_t Lambda = 40; using AssignmentType = nil::blueprint::assignment; @@ -137,7 +139,7 @@ void test_fp12_inversion(std::vector public_inpu using value_type = typename FieldType::value_type; using var = crypto3::zk::snark::plonk_variable; - using component_type = blueprint::components::fp12_inversion; + using component_type = blueprint::components::fp12_inversion; typename component_type::input_type instance_input; typename std::array X; @@ -189,11 +191,13 @@ void test_fp12_inversion(std::vector public_inpu ); if (expected_to_pass) { - nil::crypto3::test_component ( - component_instance, public_input, result_check, instance_input, nil::crypto3::detail::connectedness_check_type::STRONG); + nil::crypto3::test_component ( + component_instance, desc,public_input, result_check, instance_input, + nil::blueprint::connectedness_check_type::type::STRONG); } else { - nil::crypto3::test_component_to_fail ( - component_instance, public_input, result_check, instance_input, nil::crypto3::detail::connectedness_check_type::STRONG); + nil::crypto3::test_component_to_fail ( + component_instance, desc, public_input, result_check, instance_input, + nil::blueprint::connectedness_check_type::type::STRONG); } } @@ -203,9 +207,9 @@ void test_fp12_small_power(std::vector public_in constexpr std::size_t ConstantColumns = 0; constexpr std::size_t SelectorColumns = 1; - using ArithmetizationParams = - crypto3::zk::snark::plonk_arithmetization_params; - using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; + zk::snark::plonk_table_description desc( + WitnessColumns, PublicInputColumns, ConstantColumns, SelectorColumns); + using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; using hash_type = nil::crypto3::hashes::keccak_1600<256>; constexpr std::size_t Lambda = 40; using AssignmentType = nil::blueprint::assignment; @@ -213,7 +217,7 @@ void test_fp12_small_power(std::vector public_in using value_type = typename FieldType::value_type; using var = crypto3::zk::snark::plonk_variable; - using component_type = blueprint::components::fp12_small_power; + using component_type = blueprint::components::fp12_small_power; typename component_type::input_type instance_input; typename std::array X; @@ -262,8 +266,9 @@ void test_fp12_small_power(std::vector public_in std::array{} // public inputs ); - nil::crypto3::test_component ( - component_instance, public_input, result_check, instance_input, nil::crypto3::detail::connectedness_check_type::STRONG); + nil::crypto3::test_component ( + component_instance, desc, public_input, result_check, instance_input, + nil::blueprint::connectedness_check_type::type::STRONG); } template @@ -272,9 +277,9 @@ void test_fp12_frobenius_map(std::vector public_ constexpr std::size_t ConstantColumns = 0; constexpr std::size_t SelectorColumns = 1; - using ArithmetizationParams = - crypto3::zk::snark::plonk_arithmetization_params; - using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; + zk::snark::plonk_table_description desc( + WitnessColumns, PublicInputColumns, ConstantColumns, SelectorColumns); + using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; using hash_type = nil::crypto3::hashes::keccak_1600<256>; constexpr std::size_t Lambda = 40; using AssignmentType = nil::blueprint::assignment; @@ -282,7 +287,7 @@ void test_fp12_frobenius_map(std::vector public_ using value_type = typename FieldType::value_type; using var = crypto3::zk::snark::plonk_variable; - using component_type = blueprint::components::fp12_frobenius_map; + using component_type = blueprint::components::fp12_frobenius_map; typename component_type::input_type instance_input; typename std::array X; @@ -336,8 +341,9 @@ void test_fp12_frobenius_map(std::vector public_ std::array{} // public inputs ); - nil::crypto3::test_component ( - component_instance, public_input, result_check, instance_input, nil::crypto3::detail::connectedness_check_type::STRONG); + nil::crypto3::test_component ( + component_instance, desc, public_input, result_check, instance_input, + nil::blueprint::connectedness_check_type::type::STRONG); } template @@ -346,9 +352,9 @@ void test_fp12_power_t(std::vector public_input) constexpr std::size_t ConstantColumns = 0; constexpr std::size_t SelectorColumns = (WitnessColumns == 12)? 4 : 5; - using ArithmetizationParams = - crypto3::zk::snark::plonk_arithmetization_params; - using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; + zk::snark::plonk_table_description desc( + WitnessColumns, PublicInputColumns, ConstantColumns, SelectorColumns); + using ArithmetizationType = crypto3::zk::snark::plonk_constraint_system; using hash_type = nil::crypto3::hashes::keccak_1600<256>; constexpr std::size_t Lambda = 40; using AssignmentType = nil::blueprint::assignment; @@ -356,7 +362,7 @@ void test_fp12_power_t(std::vector public_input) using value_type = typename FieldType::value_type; using var = crypto3::zk::snark::plonk_variable; - using component_type = blueprint::components::fp12_power_t; + using component_type = blueprint::components::fp12_power_t; typename component_type::input_type instance_input; typename std::array X; @@ -405,8 +411,9 @@ void test_fp12_power_t(std::vector public_input) std::array{} // public inputs ); - nil::crypto3::test_component ( - component_instance, public_input, result_check, instance_input, nil::crypto3::detail::connectedness_check_type::STRONG); + nil::crypto3::test_component ( + component_instance, desc, public_input, result_check, instance_input, + nil::blueprint::connectedness_check_type::type::STRONG); } static const std::size_t random_tests_amount = 10;