Added a basic packer test.

include/nil/crypto3/zk/snark/arithmetization/plonk/lookup_table_definition.hpp

@@ -302,14 +302,14 @@ namespace nil {
                             lookup_table_ids, lookup_tables, bp, assignment, constant_columns_ids, usable_rows,
                             detail::next_power_of_two_minus_3(max_usable_rows));
                     }
-                    // std::cout << "Showing the layout:" << std::endl;
-                    // for (const auto &[table_name, column_count, rows_amount, fold_count, layout_coords] : layout) {
-                    //     const auto &[layout_x, layout_y] = layout_coords;
-                    //     std::cout << table_name.get()
-                    //               << " Columns: " << column_count << " Rows: " << rows_amount << " Fold: " << fold_count
-                    //               << " LX: " << layout_x << " LY: " << layout_y << std::endl;
-                    // }
-                    // std::cout << "usable_rows_after: " << usable_rows_after << std::endl;
+                    std::cout << "Showing the layout:" << std::endl;
+                    for (const auto &[table_name, column_count, rows_amount, fold_count, layout_coords] : layout) {
+                        const auto &[layout_x, layout_y] = layout_coords;
+                        std::cout << table_name.get()
+                                  << " Columns: " << column_count << " Rows: " << rows_amount << " Fold: " << fold_count
+                                  << " LX: " << layout_x << " LY: " << layout_y << std::endl;
+                    }
+                    std::cout << "usable_rows_after: " << usable_rows_after << std::endl;
                     // Otherwise we can fit the current tables
                     std::sort(layout.begin(), layout.end(),
                                 [](const auto &lhs, const auto &rhs) {
@@ -344,8 +344,9 @@ namespace nil {
                             for (std::size_t column = layout_x + fold * column_amount;
                                     column < layout_x + (fold + 1) * column_amount; column++) {
 
-                                for (std::size_t row = layout_y, table_row = 0; row < layout_y + rows_amount;
-                                        row++, table_row++) {
+                                for (std::size_t row = layout_y, table_row = fold * rows_amount;
+                                     row < layout_y + rows_amount;
+                                     row++, table_row++) {
 
                                     if (table_row < table_rows_amount) {
                                         constant_columns[column][row] =
@@ -366,7 +367,7 @@ namespace nil {
                                 continue;
                             }
                             // Check if the current rows are already included in some selector so that we reuse it
-                            // Because folded table would not have a non-full subtable, this works
+                            // This works because a folded table would not have a non-full subtable
                             std::size_t next_selector;
                             if (selector_ids.find(std::make_pair(subtable.begin, subtable.end)) !=
                                 selector_ids.end()) {

test/CMakeLists.txt

@@ -84,7 +84,7 @@ set(TESTS_NAMES
     "systems/plonk/pickles/oracles"
     "systems/plonk/pickles/to_field"
     "systems/plonk/pickles/to_group"
-    
+
     "systems/plonk/placeholder/placeholder"
     "systems/plonk/placeholder/performance"
 
@@ -105,6 +105,8 @@ set(TESTS_NAMES
     "transcript/transcript"
     "transcript/kimchi_transcript"
 
+    "systems/plonk/placeholder/lookup_table_packer"
+
     "systems/plonk/plonk_constraint")
 
 foreach(TEST_NAME ${TESTS_NAMES})

test/systems/plonk/placeholder/lookup_table_packer.cpp

@@ -0,0 +1,140 @@
+//---------------------------------------------------------------------------//
+// Copyright (c) 2023 Dmitrii Tabalin
+//
+// MIT License
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//---------------------------------------------------------------------------//
+
+#include <cstddef>
+#define BOOST_TEST_MODULE zk_lookup_table_packer_test
+
+#include <iostream>
+
+#include <boost/test/unit_test.hpp>
+
+#include <nil/crypto3/algebra/curves/pallas.hpp>
+#include <nil/crypto3/algebra/fields/arithmetic_params/pallas.hpp>
+
+#include <nil/crypto3/hash/algorithm/hash.hpp>
+#include <nil/crypto3/hash/keccak.hpp>
+
+#include <nil/crypto3/zk/snark/systems/plonk/placeholder/lookup_argument.hpp>
+
+#include <nil/crypto3/zk/snark/arithmetization/plonk/params.hpp>
+#include <nil/crypto3/zk/snark/arithmetization/plonk/constraint_system.hpp>
+#include <nil/crypto3/zk/snark/arithmetization/plonk/assignment.hpp>
+#include <nil/crypto3/zk/snark/arithmetization/plonk/lookup_table_definition.hpp>
+
+using namespace nil::crypto3;
+using namespace nil::crypto3::zk;
+using namespace nil::crypto3::zk::snark;
+
+class test_lookup_table : public lookup_table_definition<algebra::curves::pallas::base_field_type> {
+public:
+    std::size_t rows_amount;
+    std::size_t columns_amount;
+
+    test_lookup_table(std::size_t _rows_amount, std::size_t _columns_amount) :
+        lookup_table_definition<algebra::curves::pallas::base_field_type>(
+            "test_table" + std::to_string(_rows_amount) + "_" + std::to_string(_columns_amount)),
+        rows_amount(_rows_amount),
+        columns_amount(_columns_amount) {
+            std::vector<std::size_t> column_indices(columns_amount);
+            std::iota(column_indices.begin(), column_indices.end(), 0);
+            this->subtables["full"] = {column_indices, 0, rows_amount - 1};
+        }
+
+    void generate() override {
+        _table.resize(columns_amount);
+        for (std::size_t i = 0; i < columns_amount; i++) {
+            _table[i].resize(rows_amount);
+        }
+        for (std::size_t i = 0; i < columns_amount; ++i) {
+            for (std::size_t j = 0; j < rows_amount; j++) {
+                this->_table[i][j] = i * rows_amount + j;
+            }
+        }
+    }
+
+    std::size_t get_columns_number() override {
+        return columns_amount;
+    }
+    virtual std::size_t get_rows_number() override {
+        return rows_amount;
+    }
+};
+
+BOOST_AUTO_TEST_SUITE(lookup_table_packer_test_suite)
+
+BOOST_AUTO_TEST_CASE(horizontal_lookup_table_packer_test) {
+    using curve_type = algebra::curves::pallas;
+    using FieldType = typename curve_type::base_field_type;
+    constexpr std::size_t WitnessColumns = 9;
+    constexpr std::size_t PublicInputColumns = 1;
+    constexpr std::size_t ConstantColumns = 33;
+    constexpr std::size_t SelectorColumns = 50;
+    using hash_type = nil::crypto3::hashes::keccak_1600<256>;
+    constexpr std::size_t Lambda = 1;
+
+    using ArithmetizationParams = plonk_arithmetization_params<WitnessColumns,
+        PublicInputColumns, ConstantColumns, SelectorColumns>;
+    using ArithmetizationType = plonk_constraint_system<FieldType, ArithmetizationParams>;
+    plonk_constraint_system<FieldType, ArithmetizationParams> bp;
+    plonk_assignment_table<FieldType, ArithmetizationParams> assignment;
+
+    std::map<std::string, std::shared_ptr<lookup_table_definition<FieldType>>> lookup_tables;
+    std::map<std::string, std::size_t> lookup_table_ids;
+
+    std::vector<std::size_t> constant_columns_ids(ConstantColumns);
+    std::iota(constant_columns_ids.begin(), constant_columns_ids.end(), 0);
+
+    test_lookup_table table(4, 5);
+    lookup_tables[table.table_name] = std::make_shared<test_lookup_table>(table);
+    lookup_table_ids[table.table_name + "/full"] = 1;
+
+    const std::size_t rows_amount = pack_lookup_tables_horizontal<FieldType, ArithmetizationParams>(
+        lookup_table_ids,
+        lookup_tables,
+        bp,
+        assignment,
+        constant_columns_ids,
+        0,
+        2);
+    // Check that the folding scheme worked correctly
+    const auto &values = table.get_table();
+    const auto &constants = assignment.constants();
+    for (std::size_t column = 0; column < table.get_columns_number(); column++) {
+        for (std::size_t row = 0; row < table.get_rows_number(); row++) {
+            const std::size_t assignment_row = 1 + row % 2;
+            const std::size_t assignment_column = column + row / 2 * table.columns_amount;
+            BOOST_CHECK_EQUAL(constants[assignment_column][assignment_row], values[column][row]);
+        }
+    }
+    // Check that the selector is ther
+    const auto &selectors = assignment.selectors();
+    BOOST_CHECK_EQUAL(selectors[1][0], 0);
+    for (std::size_t row = 1; row < 3; row++) {
+        BOOST_CHECK_EQUAL(selectors[1][row], 1);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+