From 844a9deafc8441671f135fdd05734aa68229d02e Mon Sep 17 00:00:00 2001 From: Insun35 Date: Thu, 13 Jun 2024 18:57:01 +0900 Subject: [PATCH] test(zk): implement `MultiLookupCircuit` Introduce `MultiLookupCircuit` for testing `LogDerivativeHalo2` scheme. See https://github.com/scroll-tech/halo2/blob/1070391642dd64b2d68b47ec246cba9e35bd3c15/halo2_proofs/tests/plonk_api.rs --- tachyon/zk/plonk/examples/BUILD.bazel | 25 + .../plonk/examples/circuit_test_type_traits.h | 6 + .../zk/plonk/examples/multi_lookup_circuit.h | 376 ++++++++ .../examples/multi_lookup_circuit_test.cc | 33 + .../examples/multi_lookup_circuit_test_data.h | 879 ++++++++++++++++++ 5 files changed, 1319 insertions(+) create mode 100644 tachyon/zk/plonk/examples/multi_lookup_circuit.h create mode 100644 tachyon/zk/plonk/examples/multi_lookup_circuit_test.cc create mode 100644 tachyon/zk/plonk/examples/multi_lookup_circuit_test_data.h diff --git a/tachyon/zk/plonk/examples/BUILD.bazel b/tachyon/zk/plonk/examples/BUILD.bazel index 0dedf2886d..f7f00c033c 100644 --- a/tachyon/zk/plonk/examples/BUILD.bazel +++ b/tachyon/zk/plonk/examples/BUILD.bazel @@ -33,6 +33,7 @@ tachyon_cc_library( "//tachyon/zk/base/commitments:gwc_extension", "//tachyon/zk/base/commitments:shplonk_extension", "//tachyon/zk/lookup/halo2:scheme", + "//tachyon/zk/lookup/log_derivative_halo2:scheme", "//tachyon/zk/plonk/examples/fibonacci:fibonacci1_circuit", "//tachyon/zk/plonk/examples/fibonacci:fibonacci2_circuit", "//tachyon/zk/plonk/examples/fibonacci:fibonacci3_circuit", @@ -47,6 +48,8 @@ tachyon_cc_library( testonly = True, hdrs = ["circuit_test.h"], deps = [ + ":multi_lookup_circuit", + ":multi_lookup_circuit_test_data", ":point", ":shuffle_circuit", ":shuffle_circuit_test_data", @@ -77,6 +80,19 @@ tachyon_cc_library( hdrs = ["point.h"], ) +tachyon_cc_library( + name = "multi_lookup_circuit", + hdrs = ["multi_lookup_circuit.h"], + deps = ["//tachyon/zk/plonk/constraint_system:circuit"], +) + +tachyon_cc_library( + name = "multi_lookup_circuit_test_data", + testonly = True, + hdrs = ["multi_lookup_circuit_test_data.h"], + deps = COMMON_TEST_DATA_DEPS, +) + tachyon_cc_library( name = "shuffle_circuit", hdrs = ["shuffle_circuit.h"], @@ -119,6 +135,15 @@ tachyon_cc_library( deps = COMMON_TEST_DATA_DEPS + ["//tachyon/base:range"], ) +tachyon_cc_unittest( + name = "multi_lookup_circuit_test", + srcs = ["multi_lookup_circuit_test.cc"], + deps = COMMON_TEST_DEPS + [ + ":multi_lookup_circuit", + ":multi_lookup_circuit_test_data", + ], +) + tachyon_cc_unittest( name = "shuffle_circuit_test", srcs = ["shuffle_circuit_test.cc"], diff --git a/tachyon/zk/plonk/examples/circuit_test_type_traits.h b/tachyon/zk/plonk/examples/circuit_test_type_traits.h index d10b66d4d7..d889a0b0d5 100644 --- a/tachyon/zk/plonk/examples/circuit_test_type_traits.h +++ b/tachyon/zk/plonk/examples/circuit_test_type_traits.h @@ -7,6 +7,7 @@ #include "tachyon/zk/base/commitments/gwc_extension.h" #include "tachyon/zk/base/commitments/shplonk_extension.h" #include "tachyon/zk/lookup/halo2/scheme.h" +#include "tachyon/zk/lookup/log_derivative_halo2/scheme.h" #include "tachyon/zk/plonk/examples/fibonacci/fibonacci1_circuit.h" #include "tachyon/zk/plonk/examples/fibonacci/fibonacci2_circuit.h" #include "tachyon/zk/plonk/examples/fibonacci/fibonacci3_circuit.h" @@ -26,6 +27,11 @@ using BN254Halo2LS = lookup::halo2::Scheme; +using BN254LogDerivativeHalo2LS = + lookup::log_derivative_halo2::Scheme; + template constexpr bool IsSimpleFloorPlanner = std::is_same_v>; diff --git a/tachyon/zk/plonk/examples/multi_lookup_circuit.h b/tachyon/zk/plonk/examples/multi_lookup_circuit.h new file mode 100644 index 0000000000..4f2d253552 --- /dev/null +++ b/tachyon/zk/plonk/examples/multi_lookup_circuit.h @@ -0,0 +1,376 @@ +#ifndef TACHYON_ZK_PLONK_EXAMPLES_MULTI_LOOKUP_CIRCUIT_H_ +#define TACHYON_ZK_PLONK_EXAMPLES_MULTI_LOOKUP_CIRCUIT_H_ + +#include +#include +#include + +#include "tachyon/zk/plonk/constraint_system/circuit.h" + +namespace tachyon::zk::plonk { + +template +class MultiLookupCircuitConfig { + public: + using Field = F; + + MultiLookupCircuitConfig() = default; + MultiLookupCircuitConfig(const AdviceColumnKey& a, const AdviceColumnKey& b, + const AdviceColumnKey& c, const AdviceColumnKey& d, + const AdviceColumnKey& e, const FixedColumnKey& sa, + const FixedColumnKey& sb, const FixedColumnKey& sc, + const FixedColumnKey& sf, const FixedColumnKey& sm, + const FixedColumnKey& sp, + const LookupTableColumn& sl) + : a_(a), + b_(b), + c_(c), + d_(d), + e_(e), + sa_(sa), + sb_(sb), + sc_(sc), + sf_(sf), + sm_(sm), + sp_(sp), + sl_(sl) {} + + MultiLookupCircuitConfig Clone() const { + return {a_, b_, c_, d_, e_, sa_, sb_, sc_, sf_, sm_, sp_, sl_}; + } + + const AdviceColumnKey& a() const { return a_; } + const AdviceColumnKey& b() const { return b_; } + const AdviceColumnKey& c() const { return c_; } + const AdviceColumnKey& d() const { return d_; } + const AdviceColumnKey& e() const { return e_; } + const FixedColumnKey& sa() const { return sa_; } + const FixedColumnKey& sb() const { return sb_; } + const FixedColumnKey& sc() const { return sc_; } + const FixedColumnKey& sf() const { return sf_; } + const FixedColumnKey& sm() const { return sm_; } + const FixedColumnKey& sp() const { return sp_; } + const LookupTableColumn& sl() const { return sl_; } + + static MultiLookupCircuitConfig Configure(ConstraintSystem& meta) { + AdviceColumnKey e = meta.CreateAdviceColumn(); + AdviceColumnKey a = meta.CreateAdviceColumn(); + AdviceColumnKey b = meta.CreateAdviceColumn(); + FixedColumnKey sf = meta.CreateFixedColumn(); + AdviceColumnKey c = meta.CreateAdviceColumn(); + AdviceColumnKey d = meta.CreateAdviceColumn(); + InstanceColumnKey p = meta.CreateInstanceColumn(); + + meta.EnableEquality(a); + meta.EnableEquality(b); + meta.EnableEquality(c); + + FixedColumnKey sm = meta.CreateFixedColumn(); + FixedColumnKey sa = meta.CreateFixedColumn(); + FixedColumnKey sb = meta.CreateFixedColumn(); + FixedColumnKey sc = meta.CreateFixedColumn(); + FixedColumnKey sp = meta.CreateFixedColumn(); + LookupTableColumn sl = meta.CreateLookupTableColumn(); + + Selector dummy = meta.CreateComplexSelector(); + Selector dummy_2 = meta.CreateComplexSelector(); + Selector dummy_3 = meta.CreateComplexSelector(); + + LookupTableColumn dummy_table = meta.CreateLookupTableColumn(); + + // + // A B ... sl + // [ + // instance 0 ... 0 + // a a ... 0 + // a a² ... 0 + // a a ... 0 + // a a² ... 0 + // ... ... ... ... + // ... ... ... instance + // ... ... ... a + // ... ... ... a + // ... ... ... 0 + // ] + // + + meta.Lookup("lookup", [&a, &sl](VirtualCells meta) { + std::unique_ptr> a_expr = meta.QueryAny(a, Rotation::Cur()); + lookup::Pairs>, LookupTableColumn> + lookup_pairs; + lookup_pairs.emplace_back(std::move(a_expr), sl); + return lookup_pairs; + }); + + meta.Lookup("lookup_same", [&a, &sl](VirtualCells meta) { + std::unique_ptr> a_expr = meta.QueryAny(a, Rotation::Cur()); + lookup::Pairs>, LookupTableColumn> + lookup_pairs; + lookup_pairs.emplace_back(std::move(a_expr), sl); + return lookup_pairs; + }); + + meta.Lookup("lookup_same", [&b, &dummy, &dummy_2, &dummy_3, + &dummy_table](VirtualCells meta) { + std::unique_ptr> b_expr = meta.QueryAny(b, Rotation::Cur()); + std::unique_ptr> dummy_expr = meta.QuerySelector(dummy); + std::unique_ptr> dummy_2_expr = meta.QuerySelector(dummy_2); + std::unique_ptr> dummy_3_expr = meta.QuerySelector(dummy_3); + + lookup::Pairs>, LookupTableColumn> + lookup_pairs; + lookup_pairs.emplace_back(std::move(dummy_expr) * + std::move(dummy_2_expr) * + std::move(dummy_3_expr) * std::move(b_expr), + dummy_table); + return lookup_pairs; + }); + + meta.CreateGate("Combined add-mult", [&](VirtualCells meta) { + std::unique_ptr> d_expr = + meta.QueryAdvice(d, Rotation::Next()); + std::unique_ptr> a_expr = + meta.QueryAdvice(a, Rotation::Cur()); + std::unique_ptr> sf_expr = + meta.QueryFixed(sf, Rotation::Cur()); + std::unique_ptr> e_expr = + meta.QueryAdvice(e, Rotation::Prev()); + std::unique_ptr> b_expr = + meta.QueryAdvice(b, Rotation::Cur()); + std::unique_ptr> c_expr = + meta.QueryAdvice(c, Rotation::Cur()); + + std::unique_ptr> sa_expr = + meta.QueryFixed(sa, Rotation::Cur()); + std::unique_ptr> sb_expr = + meta.QueryFixed(sb, Rotation::Cur()); + std::unique_ptr> sc_expr = + meta.QueryFixed(sc, Rotation::Cur()); + std::unique_ptr> sm_expr = + meta.QueryFixed(sm, Rotation::Cur()); + + std::unique_ptr> a_clone = a_expr.get()->Clone(); + std::unique_ptr> b_clone = b_expr.get()->Clone(); + + std::vector> constraints; + constraints.emplace_back( + std::move(a_clone) * std::move(sa_expr) + + std::move(b_clone) * std::move(sb_expr) + + std::move(a_expr) * std::move(b_expr) * std::move(sm_expr) - + (std::move(c_expr) * std::move(sc_expr)) + + std::move(sf_expr) * (std::move(d_expr) * std::move(e_expr))); + + return constraints; + }); + + meta.CreateGate("Public input", [&](VirtualCells meta) { + std::unique_ptr> a_expr = + meta.QueryAdvice(a, Rotation::Cur()); + std::unique_ptr> p_expr = + meta.QueryInstance(p, Rotation::Cur()); + std::unique_ptr> sp_expr = + meta.QueryFixed(sp, Rotation::Cur()); + std::vector> constraints; + constraints.emplace_back(std::move(sp_expr) * + (std::move(a_expr) - std::move(p_expr))); + return constraints; + }); + + meta.EnableEquality(sf); + meta.EnableEquality(e); + meta.EnableEquality(d); + meta.EnableEquality(p); + meta.EnableEquality(sm); + meta.EnableEquality(sa); + meta.EnableEquality(sb); + meta.EnableEquality(sc); + meta.EnableEquality(sp); + + return {a, b, c, d, e, sa, sb, sc, sf, sm, sp, sl}; + } + + private: + AdviceColumnKey a_; + AdviceColumnKey b_; + AdviceColumnKey c_; + AdviceColumnKey d_; + AdviceColumnKey e_; + FixedColumnKey sa_; + FixedColumnKey sb_; + FixedColumnKey sc_; + FixedColumnKey sf_; + FixedColumnKey sm_; + FixedColumnKey sp_; + LookupTableColumn sl_; +}; + +template +class StandardPlonkChip { + public: + explicit StandardPlonkChip(MultiLookupCircuitConfig&& config) + : config_(std::move(config)) {} + + void PublicInput(Layouter* layouter, const Value& value) { + layouter->AssignRegion("public_input", [this, &value](Region& region) { + region.AssignAdvice("value", config_.a(), 0, + [&value]() { return value; }); + region.AssignFixed("public", config_.sp(), 0, + []() { return Value::Known(F::One()); }); + }); + } + + std::vector> RawMultiply( + Layouter* layouter, const std::vector>& values) { + std::vector> ret; + ret.reserve(3); + + layouter->AssignRegion( + "raw_multiply", [this, &values, &ret](Region& region) { + AssignedCell lhs = region.AssignAdvice( + "lhs", config_.a(), 0, [&values]() { return values[0]; }); + ret.push_back(std::move(lhs)); + + region.AssignAdvice("lhs⁴", config_.d(), 0, + [&values]() { return values[0].Pow(4); }); + + AssignedCell rhs = region.AssignAdvice( + "rhs", config_.b(), 0, [&values]() { return values[1]; }); + ret.push_back(std::move(rhs)); + + region.AssignAdvice("rhs⁴", config_.e(), 0, + [&values]() { return values[1].Pow(4); }); + + AssignedCell out = region.AssignAdvice( + "out", config_.c(), 0, [&values]() { return values[2]; }); + ret.push_back(std::move(out)); + + region.AssignFixed("a", config_.sa(), 0, + []() { return Value::Known(F::Zero()); }); + region.AssignFixed("b", config_.sb(), 0, + []() { return Value::Known(F::Zero()); }); + region.AssignFixed("c", config_.sc(), 0, + []() { return Value::Known(F::One()); }); + region.AssignFixed("a * b", config_.sm(), 0, + []() { return Value::Known(F::One()); }); + }); + + return ret; + } + + std::vector> RawAdd(Layouter* layouter, + const std::vector>& values) { + std::vector> ret; + ret.reserve(3); + + layouter->AssignRegion("raw_add", [this, &values, &ret](Region& region) { + AssignedCell lhs = region.AssignAdvice( + "lhs", config_.a(), 0, [&values]() { return values[0]; }); + ret.push_back(std::move(lhs)); + + region.AssignAdvice("lhs⁴", config_.d(), 0, + [&values]() { return values[0].Pow(4); }); + + AssignedCell rhs = region.AssignAdvice( + "rhs", config_.b(), 0, [&values]() { return values[1]; }); + ret.push_back(std::move(rhs)); + + region.AssignAdvice("rhs⁴", config_.e(), 0, + [&values]() { return values[1].Pow(4); }); + + AssignedCell out = region.AssignAdvice( + "out", config_.c(), 0, [&values]() { return values[2]; }); + ret.push_back(std::move(out)); + + region.AssignFixed("a", config_.sa(), 0, + []() { return Value::Known(F::One()); }); + region.AssignFixed("b", config_.sb(), 0, + []() { return Value::Known(F::One()); }); + region.AssignFixed("c", config_.sc(), 0, + []() { return Value::Known(F::One()); }); + region.AssignFixed("a * b", config_.sm(), 0, + []() { return Value::Known(F::Zero()); }); + }); + + return ret; + } + + void Copy(Layouter* layouter, const Cell& left, const Cell& right) { + layouter->AssignRegion("copy", [&left, &right](Region& region) { + region.ConstrainEqual(left, right); + region.ConstrainEqual(left, right); + }); + } + + void LookupTableFromValues(Layouter* layouter, + const std::vector& values) { + layouter->AssignLookupTable("", [this, &values](LookupTable& table) { + for (size_t i = 0; i < values.size(); ++i) { + if (!table.AssignCell("table col", config_.sl(), i, [&values, i]() { + return Value::Known(values[i]); + })) + return false; + } + return true; + }); + } + + private: + MultiLookupCircuitConfig config_; +}; + +template class _FloorPlanner> +class MultiLookupCircuit : public Circuit> { + public: + using FloorPlanner = _FloorPlanner>; + + MultiLookupCircuit() = default; + MultiLookupCircuit(const F& a, const std::vector& lookup_table) + : a_(Value::Known(a)), lookup_table_(lookup_table) {} + + std::unique_ptr>> WithoutWitness() + const override { + return std::make_unique(); + } + + static MultiLookupCircuitConfig Configure(ConstraintSystem& meta) { + return MultiLookupCircuitConfig::Configure(meta); + } + + void Synthesize(MultiLookupCircuitConfig&& config, + Layouter* layouter) const override { + StandardPlonkChip cs(std::move(config)); + + cs.PublicInput(layouter, Value::Known(F::One() + F::One())); + + for (size_t i = 0; i < 10; ++i) { + Value a_squared = a_.SquareImpl(); + std::vector> mul_values; + mul_values.reserve(3); + mul_values.push_back(a_); + mul_values.push_back(a_); + mul_values.push_back(a_squared); + std::vector> mul_cells = + cs.RawMultiply(layouter, mul_values); + + Value fin = a_squared.Add(a_); + std::vector> add_values; + add_values.reserve(3); + add_values.push_back(a_); + add_values.push_back(a_squared); + add_values.push_back(fin); + std::vector> add_cells = cs.RawAdd(layouter, add_values); + + cs.Copy(layouter, mul_cells[0].cell(), add_cells[0].cell()); + cs.Copy(layouter, add_cells[1].cell(), mul_cells[2].cell()); + } + + cs.LookupTableFromValues(layouter, lookup_table_); + } + + private: + Value a_; + std::vector lookup_table_; +}; +} // namespace tachyon::zk::plonk + +#endif // TACHYON_ZK_PLONK_EXAMPLES_MULTI_LOOKUP_CIRCUIT_H_ diff --git a/tachyon/zk/plonk/examples/multi_lookup_circuit_test.cc b/tachyon/zk/plonk/examples/multi_lookup_circuit_test.cc new file mode 100644 index 0000000000..c05ea58449 --- /dev/null +++ b/tachyon/zk/plonk/examples/multi_lookup_circuit_test.cc @@ -0,0 +1,33 @@ +#include "tachyon/zk/plonk/examples/multi_lookup_circuit.h" + +#include "gtest/gtest.h" + +#include "tachyon/zk/plonk/examples/circuit_test.h" +#include "tachyon/zk/plonk/examples/multi_lookup_circuit_test_data.h" +#include "tachyon/zk/plonk/layout/floor_planner/simple_floor_planner.h" + +namespace tachyon::zk::plonk { + +namespace { + +template +class MultiLookupCircuitTest + : public CircuitTest> {}; + +} // namespace + +// clang-format off +using MultiLookupTestArgumentsList = testing::Types< + TestArguments, BN254SHPlonk, BN254LogDerivativeHalo2LS>, + TestArguments, BN254GWC, BN254LogDerivativeHalo2LS>>; +// clang-format on + +TYPED_TEST_SUITE(MultiLookupCircuitTest, MultiLookupTestArgumentsList); + +TYPED_TEST(MultiLookupCircuitTest, CreateProof) { this->CreateProofTest(); } +TYPED_TEST(MultiLookupCircuitTest, VerifyProof) { this->VerifyProofTest(); } + +} // namespace tachyon::zk::plonk diff --git a/tachyon/zk/plonk/examples/multi_lookup_circuit_test_data.h b/tachyon/zk/plonk/examples/multi_lookup_circuit_test_data.h new file mode 100644 index 0000000000..625d20982c --- /dev/null +++ b/tachyon/zk/plonk/examples/multi_lookup_circuit_test_data.h @@ -0,0 +1,879 @@ +#ifndef TACHYON_ZK_PLONK_EXAMPLES_MULTI_LOOKUP_CIRCUIT_TEST_DATA_H_ +#define TACHYON_ZK_PLONK_EXAMPLES_MULTI_LOOKUP_CIRCUIT_TEST_DATA_H_ + +#include + +#include +#include +#include + +#include "tachyon/zk/plonk/examples/circuit_test_data.h" +#include "tachyon/zk/plonk/examples/circuit_test_type_traits.h" + +namespace tachyon::zk::plonk { + +template +class MultiLookupTestData : public CircuitTestData {}; + +// PCS = SHPlonk +template +class MultiLookupTestData>> + : public CircuitTestData { + public: + using F = typename PCS::Field; + using Evals = typename PCS::Evals; + + // Set flags of values to be used as true + constexpr static bool kAdviceCommitmentsFlag = true; + constexpr static bool kLookupMPolyCommitmentsFlag = true; + constexpr static bool kPermutationProductCommitmentsFlag = true; + constexpr static bool kLookupSumCommitmentsFlag = true; + constexpr static bool kVanishingHPolyCommitmentsFlag = true; + constexpr static bool kAdviceEvalsFlag = true; + constexpr static bool kFixedEvalsFlag = true; + constexpr static bool kCommonPermutationEvalsFlag = true; + constexpr static bool kPermutationProductEvalsFlag = true; + constexpr static bool kPermutationProductNextEvalsFlag = true; + constexpr static bool kLookupSumEvalsFlag = true; + constexpr static bool kLookupSumNextEvalsFlag = true; + constexpr static bool kPermutationProductLastEvalsFlag = true; + constexpr static bool kLookupMEvalsFlag = true; + + constexpr static size_t kN = 32; + + constexpr static std::string_view kPinnedConstraintSystem = ""; + + constexpr static bool kCycleStoreSelectors[][kN] = {{}}; + + constexpr static std::string_view kPinnedVerifyingKey = ""; + + constexpr static std::string_view kTranscriptRepr = ""; + + constexpr static std::string_view kLFirst[] = {}; + + constexpr static uint8_t kProof[] = { + 176, 39, 119, 154, 232, 230, 108, 49, 145, 63, 70, 98, 95, 39, 79, + 60, 158, 217, 82, 29, 203, 144, 111, 78, 192, 88, 4, 136, 239, 87, + 182, 33, 111, 96, 195, 90, 244, 247, 129, 190, 245, 7, 134, 122, 7, + 38, 111, 134, 98, 219, 109, 209, 22, 189, 233, 94, 254, 37, 168, 159, + 176, 235, 222, 156, 235, 153, 242, 158, 111, 46, 218, 237, 137, 157, 79, + 236, 121, 54, 239, 149, 20, 6, 230, 238, 214, 254, 55, 128, 121, 203, + 148, 43, 205, 237, 34, 148, 104, 119, 235, 159, 27, 152, 52, 194, 129, + 28, 241, 142, 82, 119, 54, 218, 65, 98, 24, 12, 186, 15, 178, 46, + 117, 129, 0, 141, 246, 154, 214, 166, 53, 198, 144, 126, 19, 184, 239, + 70, 130, 205, 109, 242, 43, 222, 115, 252, 25, 135, 221, 140, 138, 27, + 149, 217, 0, 210, 118, 86, 211, 115, 60, 19, 176, 39, 119, 154, 232, + 230, 108, 49, 145, 63, 70, 98, 95, 39, 79, 60, 158, 217, 82, 29, + 203, 144, 111, 78, 192, 88, 4, 136, 239, 87, 182, 33, 111, 96, 195, + 90, 244, 247, 129, 190, 245, 7, 134, 122, 7, 38, 111, 134, 98, 219, + 109, 209, 22, 189, 233, 94, 254, 37, 168, 159, 176, 235, 222, 156, 235, + 153, 242, 158, 111, 46, 218, 237, 137, 157, 79, 236, 121, 54, 239, 149, + 20, 6, 230, 238, 214, 254, 55, 128, 121, 203, 148, 43, 205, 237, 34, + 148, 104, 119, 235, 159, 27, 152, 52, 194, 129, 28, 241, 142, 82, 119, + 54, 218, 65, 98, 24, 12, 186, 15, 178, 46, 117, 129, 0, 141, 246, + 154, 214, 166, 53, 198, 144, 126, 19, 184, 239, 70, 130, 205, 109, 242, + 43, 222, 115, 252, 25, 135, 221, 140, 138, 27, 149, 217, 0, 210, 118, + 86, 211, 115, 60, 19, 124, 201, 129, 103, 17, 76, 46, 226, 149, 158, + 64, 63, 44, 184, 222, 33, 58, 204, 143, 248, 241, 138, 206, 165, 188, + 112, 6, 206, 239, 70, 18, 0, 156, 42, 177, 61, 71, 15, 22, 47, + 239, 184, 119, 62, 93, 114, 196, 215, 241, 206, 252, 57, 228, 10, 218, + 80, 89, 7, 22, 56, 81, 45, 251, 149, 124, 201, 129, 103, 17, 76, + 46, 226, 149, 158, 64, 63, 44, 184, 222, 33, 58, 204, 143, 248, 241, + 138, 206, 165, 188, 112, 6, 206, 239, 70, 18, 0, 156, 42, 177, 61, + 71, 15, 22, 47, 239, 184, 119, 62, 93, 114, 196, 215, 241, 206, 252, + 57, 228, 10, 218, 80, 89, 7, 22, 56, 81, 45, 251, 149, 85, 114, + 229, 183, 207, 186, 52, 210, 168, 152, 142, 238, 30, 140, 229, 68, 92, + 206, 254, 23, 111, 132, 200, 211, 37, 251, 253, 185, 82, 116, 245, 138, + 30, 251, 146, 72, 211, 253, 167, 86, 140, 141, 154, 48, 105, 237, 92, + 122, 34, 156, 8, 27, 211, 92, 16, 45, 250, 207, 19, 210, 128, 168, + 98, 2, 117, 246, 140, 193, 98, 186, 194, 61, 183, 255, 137, 212, 228, + 148, 184, 1, 223, 163, 139, 47, 30, 34, 18, 51, 17, 246, 34, 159, + 221, 182, 215, 5, 95, 241, 47, 41, 128, 154, 204, 17, 131, 53, 251, + 100, 244, 193, 22, 7, 77, 38, 44, 83, 35, 42, 192, 245, 37, 227, + 171, 161, 29, 45, 233, 132, 76, 209, 200, 227, 196, 180, 197, 224, 119, + 94, 79, 45, 20, 187, 212, 44, 75, 111, 128, 157, 228, 85, 79, 85, + 128, 183, 1, 252, 125, 30, 24, 19, 57, 164, 235, 191, 3, 86, 201, + 49, 22, 177, 39, 229, 252, 83, 7, 182, 241, 112, 112, 104, 52, 38, + 193, 3, 202, 238, 150, 160, 136, 131, 18, 142, 150, 45, 72, 166, 241, + 77, 199, 0, 219, 98, 73, 85, 241, 92, 2, 116, 138, 7, 24, 88, + 19, 253, 145, 65, 91, 227, 180, 205, 112, 106, 214, 169, 100, 36, 107, + 160, 115, 50, 118, 46, 83, 118, 150, 179, 39, 243, 102, 225, 96, 197, + 149, 187, 206, 161, 10, 65, 84, 137, 21, 86, 49, 12, 39, 20, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 134, 82, 233, 121, 251, 36, 116, 252, 192, 252, 45, 82, 149, 4, + 78, 165, 177, 208, 251, 185, 29, 134, 48, 162, 162, 163, 44, 12, 252, + 51, 208, 148, 205, 69, 224, 246, 65, 250, 16, 105, 88, 133, 195, 193, + 195, 193, 248, 5, 193, 194, 168, 3, 176, 104, 248, 170, 254, 6, 225, + 136, 5, 128, 9, 47, 233, 221, 181, 122, 237, 43, 142, 53, 149, 124, + 78, 121, 238, 249, 0, 218, 24, 40, 25, 17, 151, 74, 59, 219, 127, + 38, 220, 193, 84, 103, 162, 148, 25, 208, 220, 185, 221, 220, 188, 23, + 122, 252, 245, 29, 196, 238, 153, 208, 106, 217, 242, 133, 217, 68, 130, + 107, 92, 111, 254, 71, 10, 126, 240, 28, 154, 197, 242, 128, 122, 211, + 207, 111, 221, 7, 108, 197, 235, 123, 53, 107, 46, 125, 71, 199, 17, + 31, 110, 9, 76, 50, 5, 40, 39, 220, 128, 13, 92, 42, 16, 156, + 86, 43, 103, 118, 155, 1, 126, 216, 161, 133, 111, 219, 161, 136, 31, + 81, 35, 178, 20, 38, 189, 240, 70, 116, 82, 147, 94, 140, 224, 143, + 3, 156, 80, 185, 194, 236, 211, 49, 84, 92, 143, 232, 107, 84, 193, + 227, 173, 103, 128, 32, 165, 180, 39, 161, 8, 231, 9, 154, 5, 14, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 198, 56, 64, 142, 238, 149, 224, 233, 29, 134, 88, 70, 220, + 105, 38, 101, 234, 152, 236, 142, 36, 68, 227, 247, 187, 250, 68, 33, + 26, 223, 231, 7, 128, 118, 151, 16, 20, 18, 195, 231, 102, 86, 171, + 15, 206, 99, 105, 33, 161, 44, 26, 4, 21, 162, 158, 14, 194, 107, + 173, 182, 193, 91, 33, 34, 199, 229, 205, 139, 223, 26, 226, 176, 254, + 41, 35, 223, 90, 205, 29, 0, 133, 76, 25, 200, 219, 151, 9, 106, + 88, 101, 104, 168, 24, 43, 200, 9, 40, 43, 214, 19, 31, 163, 235, + 165, 49, 68, 136, 54, 126, 98, 78, 177, 67, 224, 251, 157, 230, 170, + 42, 209, 91, 104, 79, 15, 67, 97, 163, 47, 220, 62, 12, 155, 229, + 82, 1, 128, 153, 49, 73, 42, 129, 96, 89, 3, 164, 11, 135, 4, + 230, 205, 38, 150, 169, 222, 17, 151, 38, 214, 19, 38, 233, 158, 170, + 14, 79, 145, 12, 151, 254, 102, 1, 28, 89, 103, 144, 49, 24, 79, + 240, 229, 43, 78, 33, 22, 135, 1, 129, 240, 172, 92, 235, 5, 62, + 18, 159, 200, 234, 95, 108, 82, 37, 100, 142, 141, 100, 60, 208, 21, + 171, 9, 29, 144, 96, 54, 212, 144, 170, 115, 140, 62, 67, 165, 194, + 39, 198, 56, 64, 142, 238, 149, 224, 233, 29, 134, 88, 70, 220, 105, + 38, 101, 234, 152, 236, 142, 36, 68, 227, 247, 187, 250, 68, 33, 26, + 223, 231, 7, 128, 118, 151, 16, 20, 18, 195, 231, 102, 86, 171, 15, + 206, 99, 105, 33, 161, 44, 26, 4, 21, 162, 158, 14, 194, 107, 173, + 182, 193, 91, 33, 34, 199, 229, 205, 139, 223, 26, 226, 176, 254, 41, + 35, 223, 90, 205, 29, 0, 133, 76, 25, 200, 219, 151, 9, 106, 88, + 101, 104, 168, 24, 43, 200, 9, 40, 43, 214, 19, 31, 163, 235, 165, + 49, 68, 136, 54, 126, 98, 78, 177, 67, 224, 251, 157, 230, 170, 42, + 209, 91, 104, 79, 15, 67, 97, 163, 47, 220, 62, 12, 155, 229, 82, + 1, 128, 153, 49, 73, 42, 129, 96, 89, 3, 164, 11, 135, 4, 230, + 205, 38, 150, 169, 222, 17, 151, 38, 214, 19, 38, 233, 158, 170, 14, + 79, 145, 12, 151, 254, 102, 1, 28, 89, 103, 144, 49, 24, 79, 240, + 229, 43, 78, 33, 22, 135, 1, 129, 240, 172, 92, 235, 5, 62, 18, + 159, 200, 234, 95, 108, 82, 37, 100, 142, 141, 100, 60, 208, 21, 171, + 9, 29, 144, 96, 54, 212, 144, 170, 115, 140, 62, 67, 165, 194, 39, + 107, 54, 70, 239, 140, 139, 86, 143, 224, 63, 92, 208, 10, 38, 194, + 81, 31, 69, 223, 52, 19, 65, 69, 199, 136, 175, 217, 64, 145, 136, + 250, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 86, 166, 145, 87, 56, 247, 247, 174, 150, + 29, 126, 169, 39, 5, 146, 74, 191, 204, 56, 54, 202, 142, 6, 111, + 118, 232, 173, 174, 142, 171, 169, 24, 86, 166, 145, 87, 56, 247, 247, + 174, 150, 29, 126, 169, 39, 5, 146, 74, 191, 204, 56, 54, 202, 142, + 6, 111, 118, 232, 173, 174, 142, 171, 169, 24, 60, 25, 208, 228, 37, + 164, 88, 156, 224, 66, 144, 181, 231, 197, 200, 90, 97, 191, 73, 202, + 117, 32, 25, 223, 227, 64, 30, 87, 25, 103, 159, 21, 231, 114, 62, + 125, 129, 162, 66, 49, 219, 149, 203, 133, 8, 169, 106, 56, 255, 74, + 146, 21, 98, 215, 98, 40, 151, 248, 161, 137, 253, 9, 90, 45, 43, + 217, 119, 123, 138, 161, 15, 234, 3, 60, 64, 172, 250, 147, 127, 106, + 125, 122, 12, 1, 233, 209, 16, 5, 25, 100, 217, 145, 72, 15, 238, + 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 169, 36, 182, 209, 135, 44, + 104, 99, 38, 73, 56, 140, 104, 213, 55, 119, 36, 215, 255, 25, 194, + 170, 158, 34, 231, 35, 211, 173, 224, 150, 98, 28, 255, 100, 244, 140, + 200, 231, 217, 238, 211, 219, 119, 238, 123, 221, 226, 232, 42, 66, 242, + 162, 190, 49, 244, 99, 242, 223, 40, 91, 252, 42, 47, 2, 175, 85, + 195, 234, 190, 203, 200, 185, 209, 93, 217, 217, 52, 222, 4, 174, 146, + 33, 36, 236, 119, 172, 61, 222, 95, 199, 210, 107, 143, 180, 200, 5, + 74, 199, 198, 24, 110, 33, 69, 177, 175, 115, 8, 112, 97, 37, 5, + 22, 158, 222, 69, 158, 117, 193, 129, 42, 44, 23, 28, 88, 238, 182, + 179, 42, 184, 97, 245, 34, 81, 42, 241, 68, 132, 224, 24, 91, 35, + 181, 125, 192, 238, 158, 156, 118, 222, 26, 232, 72, 10, 128, 30, 2, + 149, 233, 139, 35, 185, 30, 43, 129, 41, 99, 242, 104, 55, 26, 34, + 23, 132, 123, 179, 16, 215, 126, 126, 130, 100, 171, 147, 112, 205, 8, + 14, 63, 251, 92, 224, 24, 83, 49, 48, 237, 78, 49, 62, 241, 88, + 204, 98, 196, 143, 175, 123, 51, 8, 29, 164, 45, 141, 215, 125, 255, + 161, 36, 19, 75, 136, 98, 15, 10, 124, 238, 236, 10, 243, 40, 230, + 211, 27, 14, 2, 119, 246, 28, 151, 30, 236, 117, 182, 125, 118, 174, + 225, 62, 186, 75, 204, 101, 45, 156, 27, 31, 197, 205, 249, 65, 4, + 93, 49, 107, 192, 149, 89, 222, 43, 196, 8, 122, 153, 164, 206, 134, + 23, 251, 15, 96, 167, 151, 85, 199, 6, 154, 175, 6, 214, 139, 251, + 142, 59, 240, 178, 238, 40, 116, 62, 36, 31, 31, 240, 70, 139, 60, + 235, 233, 17, 214, 203, 107, 25, 105, 72, 30, 145, 115, 202, 39, 242, + 226, 165, 85, 252, 223, 212, 68, 178, 207, 132, 248, 11, 227, 170, 187, + 38, 131, 181, 168, 97, 154, 45, 221, 10, 93, 149, 11, 163, 25, 55, + 16, 70, 44, 119, 209, 197, 17, 243, 234, 125, 5, 188, 52, 40, 7, + 227, 158, 158, 109, 239, 54, 212, 137, 251, 123, 243, 46, 13, 132, 56, + 205, 109, 30, 182, 129, 193, 145, 79, 156, 156, 89, 221, 253, 212, 116, + 204, 124, 180, 112, 10, 83, 150, 8, 247, 31, 59, 214, 111, 253, 128, + 157, 240, 172, 36, 8, 67, 214, 156, 119, 152, 128, 118, 80, 200, 101, + 133, 240, 14, 232, 21, 211, 123, 134, 144, 115, 135, 141, 153, 212, 183, + 206, 113, 254, 196, 157, 207, 4, 50, 220, 116, 238, 107, 7, 123, 96, + 171, 150, 59, 242, 240, 39, 229, 39, 128, 3, 163, 147, 14, 176, 227, + 100, 83, 55, 108, 239, 40, 152, 49, 36, 237, 210, 52, 217, 30, 250, + 106, 47, 82, 6, 71, 233, 66, 170, 56, 6, 123, 254, 136, 247, 246, + 146, 118, 111, 244, 130, 5, 81, 128, 154, 14, 14, 149, 162, 184, 254, + 39, 195, 64, 58, 94, 126, 203, 73, 143, 253, 185, 197, 203, 242, 57, + 225, 118, 181, 177, 60, 9, 57, 248, 172, 9, 7, 247, 2, 62, 166, + 142, 50, 16, 207, 254, 238, 135, 98, 75, 253, 48, 51, 84, 62, 164, + 88, 209, 141, 48, 242, 80, 70, 170, 39, 10, 145, 240, 24, 38, 45, + 240, 179, 130, 184, 27, 132, 77, 181, 253, 5, 96, 241, 161, 201, 207, + 202, 19, 83, 34, 58, 21, 109, 197, 251, 191, 28, 239, 28, 37, 219, + 95, 12, 88, 242, 251, 245, 211, 168, 238, 163, 86, 17, 54, 254, 20, + 250, 172, 197, 206, 174, 13, 188, 33, 139, 114, 87, 244, 51, 39, 46, + 67, 39, 12, 41, 153, 35, 209, 226, 112, 97, 212, 237, 68, 197, 225, + 29, 6, 173, 110, 163, 32, 104, 197, 48, 46, 17, 67, 153, 229, 235, + 210, 15, 119, 88, 8, 21, 142, 79, 45, 86, 90, 127, 245, 242, 255, + 240, 61, 120, 32, 235, 123, 182, 116, 183, 253, 207, 183, 43, 46, 220, + 35, 157, 215, 72, 118, 249, 107, 40, 58, 131, 232, 96, 19, 122, 82, + 108, 1, 162, 42, 240, 124, 142, 84, 102, 235, 22, 181, 224, 81, 89, + 110, 17, 255, 189, 100, 105, 66, 100, 5, 4, 130, 146, 110, 180, 250, + 237, 133, 87, 127, 43, 50, 198, 143, 41, 175, 175, 122, 201, 91, 144, + 176, 4, 99, 234, 86, 10, 152, 21, 112, 208, 145, 12, 79, 145, 195, + 88, 31, 246, 158, 253, 79, 45, 69, 167, 238, 179, 224, 143, 150, 14, + 231, 96, 163, 182, 60, 227, 237, 23, 67, 54, 122, 247, 137, 21, 182, + 30, 89, 108, 164, 1, 140, 165, 96, 154, 185, 193, 247, 207, 162, 42, + 81, 58, 2, 74, 146, 98, 45, 20, 179, 187, 184, 101, 240, 248, 167, + 47, 212, 219, 42, 221, 152, 158, 196, 33, 122, 123, 103, 245, 55, 129, + 221, 88, 90, 4, 8, 6, 142, 31, 30, 17, 127, 50, 80, 192, 19, + 175, 200, 26, 32, 44, 94, 248, 42, 58, 104, 238, 241, 206, 31, 79, + 42, 1, 15, 141, 230, 206, 224, 92, 124, 69, 81, 205, 43, 25, 231, + 70, 58, 68, 13, 23, 99, 7, 175, 162, 244, 128, 193, 89, 182, 244, + 222, 251, 254, 246, 197, 199, 249, 178, 13, 157, 169, 138, 198, 192, 61, + 148, 33, 143, 114, 84, 137, 38, 233, 238, 115, 0, 156, 26, 221, 39, + 222, 102, 142, 34, 110, 166, 192, 246, 105, 20, 150, 52, 96, 178, 49, + 126, 129, 15, 125, 127, 3, 4, 39, 13, 79, 145, 195, 88, 31, 246, + 158, 253, 79, 45, 69, 167, 238, 179, 224, 143, 150, 14, 231, 96, 163, + 182, 60, 227, 237, 23, 67, 54, 122, 247, 137, 21, 54, 152, 146, 99, + 248, 247, 63, 18, 224, 89, 138, 144, 31, 181, 66, 206, 201, 7, 220, + 109, 38, 109, 144, 215, 229, 113, 216, 33, 85, 189, 17, 44, 166, 187, + 51, 10, 90, 249, 72, 126, 64, 33, 12, 17, 140, 71, 85, 29, 129, + 199, 48, 98, 168, 203, 75, 250, 125, 72, 147, 18, 168, 29, 106, 23, + 32, 44, 94, 248, 42, 58, 104, 238, 241, 206, 31, 79, 42, 1, 15, + 141, 230, 206, 224, 92, 124, 69, 81, 205, 43, 25, 231, 70, 58, 68, + 13, 23, 0, 215, 88, 104, 236, 138, 79, 64, 255, 140, 19, 138, 82, + 55, 148, 12, 108, 95, 58, 240, 229, 156, 29, 198, 175, 70, 95, 95, + 160, 198, 146, 42, 51, 98, 111, 71, 79, 161, 187, 96, 91, 252, 60, + 184, 34, 181, 83, 156, 114, 200, 155, 214, 110, 50, 36, 81, 170, 221, + 165, 187, 157, 154, 81, 29}; + + constexpr static Point kAdviceCommitments[][5] = { + {{"0x21b657ef880458c04e6f90cb1d52d99e3c4f275f62463f91316ce6e89a7727b0", + "0x018e7e556102c958d925644e9fdec38e1b6c88572a98ce9871485937ff5c9aa4"}, + {"0x1cdeebb09fa825fe5ee9bd16d16ddb62866f26077a8607f5be81f7f45ac3606f", + "0x0dd225bfadd39c83ca40e0a578ae098e3dce0b62b8bbf3445e63fe035c71ce09"}, + {"0x1422edcd2b94cb798037fed6eee6061495ef3679ec4f9d89edda2e6f9ef299eb", + "0x07aff8c1c8c754b022575c2e7e2f98483f08111f3dc0a9d7e2b119c5063c97b9"}, + {"0x26d69af68d0081752eb20fba0c186241da3677528ef11c81c234981b9feb7768", + "0x0cb675234a966e9b7fe6f87c6da86e5b3d534330dd6ebc08302da54ccee2352f"}, + {"0x133c73d35676d200d9951b8a8cdd8719fc73de2bf26dcd8246efb8137e90c635", + "0x1eb2849fbface2516b2dfa0d9ed2ec2b397a04ae228a2541d32bc83bb429de30"}}, + {{"0x21b657ef880458c04e6f90cb1d52d99e3c4f275f62463f91316ce6e89a7727b0", + "0x018e7e556102c958d925644e9fdec38e1b6c88572a98ce9871485937ff5c9aa4"}, + {"0x1cdeebb09fa825fe5ee9bd16d16ddb62866f26077a8607f5be81f7f45ac3606f", + "0x0dd225bfadd39c83ca40e0a578ae098e3dce0b62b8bbf3445e63fe035c71ce09"}, + {"0x1422edcd2b94cb798037fed6eee6061495ef3679ec4f9d89edda2e6f9ef299eb", + "0x07aff8c1c8c754b022575c2e7e2f98483f08111f3dc0a9d7e2b119c5063c97b9"}, + {"0x26d69af68d0081752eb20fba0c186241da3677528ef11c81c234981b9feb7768", + "0x0cb675234a966e9b7fe6f87c6da86e5b3d534330dd6ebc08302da54ccee2352f"}, + {"0x133c73d35676d200d9951b8a8cdd8719fc73de2bf26dcd8246efb8137e90c635", + "0x1eb2849fbface2516b2dfa0d9ed2ec2b397a04ae228a2541d32bc83bb429de30"}}, + }; + + constexpr static std::string_view kTheta = + "0x1def3cccec9613b680e85b2aec2964d537bf3f8f37c252ec6259cc42c5e4edf8"; + + constexpr static Point kLookupMPolyCommitments[][2] = { + {{"0x001246efce0670bca5ce8af1f88fcc3a21deb82c3f409e95e22e4c116781c97c", + "0x1de4836417d97b2def8418f351899aa9e5de200cac99f0bcb36f03b44c2fbb8e"}, + {"0x15fb2d513816075950da0ae439fccef1d7c4725d3e77b8ef2f160f473db12a9c", + "0x13a5bf0b4bde809ec00d335afbfb4ee7d1a01b17d5f6ba51b353be98ac7034cb"}}, + {{"0x001246efce0670bca5ce8af1f88fcc3a21deb82c3f409e95e22e4c116781c97c", + "0x1de4836417d97b2def8418f351899aa9e5de200cac99f0bcb36f03b44c2fbb8e"}, + {"0x15fb2d513816075950da0ae439fccef1d7c4725d3e77b8ef2f160f473db12a9c", + "0x13a5bf0b4bde809ec00d335afbfb4ee7d1a01b17d5f6ba51b353be98ac7034cb"}}}; + + constexpr static std::string_view kBeta = + "0x259528cdf5729d8a6e157db353d0565d0262278cf072771ddc3ee6327ebec6c0"; + + constexpr static std::string_view kGamma = + "0x1cccdd3d0042b0d92cb571c762f87a57765604f1893cb70e6f01796f26c63230"; + + constexpr static Point kPermutationProductCommitments[][2] = { + {{"0x0af57452b9fdfb25d3c8846f17fece5c44e58c1eee8e98a8d234bacfb7e57255", + "0x1436e2f19c363815cf140cf49c9499bbabaa64994aaa72ffb94df2557afee2f5"}, + {"0x0262a880d213cffa2d105cd31b089c227a5ced69309a8d8c56a7fdd34892fb1e", + "0x2853361cd32d728b82f8707b858c329db9030303f2f19a96f13f578a11e86288"}}, + {{"0x05d7b6dd9f22f6113312221e2f8ba3df01b894e4d489ffb73dc2ba62c18cf675", + "0x0bf767bf857537b0e71c2f464cb3943e844dc908275ed0068056d55104e573c6"}, + {"0x04e92d1da1abe325f5c02a23532c264d0716c1f464fb358311cc9a80292ff15f", + "0x1413f36166810082edec8b75bb4394035e805bdd7c55081f4daf484176907039"}}}; + + constexpr static Point kLookupSumCommitments[][2] = { + {{"0x13181e7dfc01b780554f55e49d806f4b2cd4bb142d4f5e77e0c5b4c4e3c8d14c", + "0x19eefc799c2f6be5d96aa720192a1a31ba243118a3cfc77ef08688dc43662f86"}, + {"0x0e128388a096eeca03c12634687070f1b60753fce527b11631c95603bfeba439", + "0x288df0de14d1ee8c44d2b90c265fd526296097884209ce8195e863266900b6af"}}, + {{"0x29d66a70cdb4e35b4191fd135818078a74025cf1554962db00c74df1a6482d96", + "0x2bfb2bb775bcbb909ef352f47259a165dbc75de70ccddacfb211fde48bdb8a57"}, + {"0x14270c3156158954410aa1cebb95c560e166f327b39676532e763273a06b2464", + "0x2e717776d2ec0939d2f928f633ac9c2e3c801e49d38814500b9b6889b97e9d12"}}}; + + constexpr static std::string_view kY = + "0x16431478000ca39c9b09adf0bbab44a5caf09bbe30f00fa329664dce2090e258"; + + constexpr static Point kVanishingHPolyCommitments[] = { + {"0x14d033fc0c2ca3a2a230861db9fbd0b1a54e0495522dfcc0fc7424fb79e95286", + "0x03c96b4d7f5e5ce7f36509f4c786d593b0c20e097f91a3f492209cf9880a047b"}, + {"0x2f09800588e106feaaf868b003a8c2c105f8c1c3c1c385586910fa41f6e045cd", + "0x268afa9c29a37595f47b6a287bb8fbc321bdb71260e2f0d9b22107d9e0a09422"}, + {"0x14a26754c1dc267fdb3b4a9711192818da00f9ee794e7c95358e2bed7ab5dde9", + "0x1fa1341042ab4fe9ceb4ac8882543ed0bd5cbdd8eb507a519b5d9ef3948e5127"}, + {"0x1cf07e0a47fe6f5c6b8244d985f2d96ad099eec41df5fc7a17bcdcddb9dcd019", + "0x1b18b22b69a22cec1bc92382f1b3f56b307ff029af50852cb70c09331d2159d6"}, + {"0x0d80dc272805324c096e1f11c7477d2e6b357bebc56c07dd6fcfd37a80f2c59a", + "0x18d6c2c58ae9ad81de8fdae13f685d305bd929c2bf328c8ed91d6afe360227ac"}, + {"0x0c5e93527446f0bd2614b223511f88a1db6f85a1d87e019b76672b569c102a5c", + "0x11df4fd2ada9780f05481db81d387f7edeeafdba986d6693650a37f1c409b229"}, + {"0x0e059a09e708a127b4a5208067ade3c1546be88f5c5431d3ecc2b9509c038fe0", + "0x20d500545e8f2f2b6b78f1c74bad1f8de483bcefedb74c89f253d09689b1ed08"}, + {"0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000"}}; + + constexpr static std::string_view kX = + "0x106d99e38440e2f0043f707031f994be95fc247aa2015965b77e3e0994753a47"; + + constexpr static std::string_view kAdviceEvals[][7] = { + {"0x07e7df1a2144fabbf7e344248eec98ea652669dc4658861de9e095ee8e4038c6", + "0x22215bc1b6ad6bc20e9ea215041a2ca1216963ce0fab5666e7c3121410977680", + "0x09c82b18a86865586a0997dbc8194c85001dcd5adf2329feb0e21adf8bcde5c7", + "0x2fa361430f4f685bd12aaae69dfbe043b14e627e36884431a5eba31f13d62b28", + "0x2613d6269711dea99626cde604870ba4035960812a493199800152e59b0c3edc", + "0x05eb5cacf081018716214e2be5f04f18319067591c0166fe970c914f0eaa9ee9", + "0x27c2a5433e8c73aa90d43660901d09ab15d03c648d8e6425526c5feac89f123e"}, + {"0x07e7df1a2144fabbf7e344248eec98ea652669dc4658861de9e095ee8e4038c6", + "0x22215bc1b6ad6bc20e9ea215041a2ca1216963ce0fab5666e7c3121410977680", + "0x09c82b18a86865586a0997dbc8194c85001dcd5adf2329feb0e21adf8bcde5c7", + "0x2fa361430f4f685bd12aaae69dfbe043b14e627e36884431a5eba31f13d62b28", + "0x2613d6269711dea99626cde604870ba4035960812a493199800152e59b0c3edc", + "0x05eb5cacf081018716214e2be5f04f18319067591c0166fe970c914f0eaa9ee9", + "0x27c2a5433e8c73aa90d43660901d09ab15d03c648d8e6425526c5feac89f123e"}}; + + constexpr static std::string_view kFixedEvals[] = { + "0x0cfa889140d9af88c745411334df451f51c2260ad05c3fe08f568b8cef46366b", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x18a9ab8eaeade8766f068eca3638ccbf4a920527a97e1d96aef7f7385791a656", + "0x18a9ab8eaeade8766f068eca3638ccbf4a920527a97e1d96aef7f7385791a656", + "0x159f6719571e40e3df192075ca49bf615ac8c5e7b59042e09c58a425e4d0193c", + "0x2d5a09fd89a1f8972862d76215924aff386aa90885cb95db3142a2817d3e72e7", + "0x12ee0f4891d964190510d1e9010c7a7d6a7f93faac403c03ea0fa18a7b77d92b", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000"}; + + constexpr static std::string_view kCommonPermutationEvals[] = { + "0x1c6296e0add323e7229eaac219ffd7247737d5688c38492663682c87d1b624a9", + "0x022f2afc5b28dff263f431bea2f2422ae8e2dd7bee77dbd3eed9e7c88cf464ff", + "0x05c8b48f6bd2c75fde3dac77ec242192ae04de34d9d95dd1b9c8cbbeeac355af", + "0x2ab3b6ee581c172c2a81c1759e45de9e16052561700873afb145216e18c6c74a", + "0x238be995021e800a48e81ade769c9eeec07db5235b18e08444f12a5122f561b8", + "0x18e05cfb3f0e08cd7093ab64827e7ed710b37b8417221a3768f26329812b1eb9", + "0x0a0f62884b1324a1ff7dd78d2da41d08337baf8fc462cc58f13e314eed303153", + "0x1f1b9c2d65cc4bba3ee1ae767db675ec1e971cf677020e1bd3e628f30aecee7c", + "0x06af9a06c75597a7600ffb1786cea4997a08c42bde5995c06b315d0441f9cdc5", + "0x27ca73911e4869196bcbd611e9eb3c8b46f01f1f243e7428eeb2f03b8efb8bd6", + "0x103719a30b955d0add2d9a61a8b58326bbaae30bf884cfb244d4dffc55a5e2f2", + "0x1e6dcd38840d2ef37bfb89d436ef6d9e9ee3072834bc057deaf311c5d1772c46"}; + + constexpr static std::string_view kPermutationProductEvals[][2] = { + {"0x0824acf09d80fd6fd63b1ff70896530a70b47ccc74d4fddd599c9c4f91c181b6", + "0x0e0e9a80510582f46f7692f6f788fe7b0638aa42e94706522f6afa1ed934d2ed"}, + {"0x2d2618f0910a27aa4650f2308dd158a43e543330fd4b6287eefecf10328ea63e", + "0x150858770fd2ebe59943112e30c56820a36ead061de1c544edd46170e2d12399"}}; + + constexpr static std::string_view kLookupSumEvals[][2] = { + {"0x040564426964bdff116e5951e0b516eb66548e7cf02aa2016c527a1360e8833a", + "0x2fa7f8f065b8bbb3142d62924a023a512aa2cff7c1b99a60a58c01a46c591eb6"}, + {"0x268954728f21943dc0c68aa99d0db2f9c7c5f6fefbdef4b659c180f4a2af0763", + "0x2c11bd5521d871e5d7906d266ddc07c9ce42b51f908a59e0123ff7f863929836"}}; + + constexpr static std::string_view kPermutationProductNextEvals[][2] = { + {"0x04cf9dc4fe71ceb7d4998d877390867bd315e80ef08565c850768098779cd643", + "0x02f70709acf839093cb1b576e139f2cbc5b9fd8f49cb7e5e3a40c327feb8a295"}, + {"0x0c5fdb251cef1cbffbc56d153a225313cacfc9a1f16005fdb54d841bb882b3f0", + "0x286bf97648d79d23dc2e2bb7cffdb774b67beb20783df0fff2f57f5a562d4f8e"}}; + + constexpr static std::string_view kLookupSumNextEvals[][2] = { + {"0x0c91d07015980a56ea6304b0905bc97aafaf298fc6322b7f5785edfab46e9282", + "0x1ac8af13c050327f111e1f8e0608045a58dd8137f5677b7a21c49e98dd2adbd4"}, + {"0x0d2704037f7d0f817e31b26034961469f6c0a66e228e66de27dd1a9c0073eee9", + "0x176a1da81293487dfa4bcba86230c7811d55478c110c21407e48f95a0a33bba6"}}; + + constexpr static std::string_view kPermutationProductLastEvals[][2] = { + {"0x24319828ef6c375364e3b00e93a3038027e527f0f23b96ab607b076bee74dc32", + ""}, + {"0x290c27432e2733f457728b21bc0daecec5acfa14fe361156a3eea8d3f5fbf258", + ""}}; + + constexpr static std::string_view kLookupMEvals[][2] = { + {"0x1589f77a364317ede33cb6a360e70e968fe0b3eea7452d4ffd9ef61f58c3914f", + "0x170d443a46e7192bcd51457c5ce0cee68d0f012a4f1fcef1ee683a2af85e2c20"}, + {"0x1589f77a364317ede33cb6a360e70e968fe0b3eea7452d4ffd9ef61f58c3914f", + "0x170d443a46e7192bcd51457c5ce0cee68d0f012a4f1fcef1ee683a2af85e2c20"}}; + + constexpr static std::string_view kHEval = + "0x0a69dc74a53324e8a340d31faef18c558f57447b2f625b6c01c3fc8800b8b1fc"; + + static void TestConfig(MultiLookupCircuitConfig& config) {} + + static Circuit GetCircuit() { + F a = *F::FromHexString( + "0x76a69c75ed45f60e667fb401dd42f877b565f7818b1d94188fb67249"); + F instance = F(2); + std::vector lookup_table = {instance, a, a, F::Zero()}; + return Circuit(std::move(a), std::move(lookup_table)); + } + + static std::vector Get2Circuits() { + Circuit circuit = GetCircuit(); + return {circuit, std::move(circuit)}; + } + + static std::vector GetInstanceColumns() { + F instance = F(2); + std::vector instance_column = {std::move(instance)}; + return {Evals(std::move(instance_column))}; + } +}; + +// PCS = GWC +template +class MultiLookupTestData>> + : public CircuitTestData { + public: + using F = typename PCS::Field; + using Evals = typename PCS::Evals; + + // Set flags of values to be used as true + constexpr static bool kAdviceCommitmentsFlag = true; + constexpr static bool kLookupMPolyCommitmentsFlag = true; + constexpr static bool kPermutationProductCommitmentsFlag = true; + constexpr static bool kLookupSumCommitmentsFlag = true; + constexpr static bool kVanishingHPolyCommitmentsFlag = true; + constexpr static bool kAdviceEvalsFlag = true; + constexpr static bool kFixedEvalsFlag = true; + constexpr static bool kCommonPermutationEvalsFlag = true; + constexpr static bool kPermutationProductEvalsFlag = true; + constexpr static bool kLookupSumEvalsFlag = true; + constexpr static bool kPermutationProductNextEvalsFlag = true; + constexpr static bool kLookupSumNextEvalsFlag = true; + constexpr static bool kPermutationProductLastEvalsFlag = true; + constexpr static bool kLookupMEvalsFlag = true; + + constexpr static size_t kN = 32; + + constexpr static std::string_view kPinnedConstraintSystem = ""; + + constexpr static bool kCycleStoreSelectors[][kN] = {{}}; + + constexpr static std::string_view kPinnedVerifyingKey = ""; + + constexpr static std::string_view kTranscriptRepr = ""; + + constexpr static uint8_t kProof[] = { + 176, 39, 119, 154, 232, 230, 108, 49, 145, 63, 70, 98, 95, 39, 79, + 60, 158, 217, 82, 29, 203, 144, 111, 78, 192, 88, 4, 136, 239, 87, + 182, 33, 111, 96, 195, 90, 244, 247, 129, 190, 245, 7, 134, 122, 7, + 38, 111, 134, 98, 219, 109, 209, 22, 189, 233, 94, 254, 37, 168, 159, + 176, 235, 222, 156, 235, 153, 242, 158, 111, 46, 218, 237, 137, 157, 79, + 236, 121, 54, 239, 149, 20, 6, 230, 238, 214, 254, 55, 128, 121, 203, + 148, 43, 205, 237, 34, 148, 104, 119, 235, 159, 27, 152, 52, 194, 129, + 28, 241, 142, 82, 119, 54, 218, 65, 98, 24, 12, 186, 15, 178, 46, + 117, 129, 0, 141, 246, 154, 214, 166, 53, 198, 144, 126, 19, 184, 239, + 70, 130, 205, 109, 242, 43, 222, 115, 252, 25, 135, 221, 140, 138, 27, + 149, 217, 0, 210, 118, 86, 211, 115, 60, 19, 176, 39, 119, 154, 232, + 230, 108, 49, 145, 63, 70, 98, 95, 39, 79, 60, 158, 217, 82, 29, + 203, 144, 111, 78, 192, 88, 4, 136, 239, 87, 182, 33, 111, 96, 195, + 90, 244, 247, 129, 190, 245, 7, 134, 122, 7, 38, 111, 134, 98, 219, + 109, 209, 22, 189, 233, 94, 254, 37, 168, 159, 176, 235, 222, 156, 235, + 153, 242, 158, 111, 46, 218, 237, 137, 157, 79, 236, 121, 54, 239, 149, + 20, 6, 230, 238, 214, 254, 55, 128, 121, 203, 148, 43, 205, 237, 34, + 148, 104, 119, 235, 159, 27, 152, 52, 194, 129, 28, 241, 142, 82, 119, + 54, 218, 65, 98, 24, 12, 186, 15, 178, 46, 117, 129, 0, 141, 246, + 154, 214, 166, 53, 198, 144, 126, 19, 184, 239, 70, 130, 205, 109, 242, + 43, 222, 115, 252, 25, 135, 221, 140, 138, 27, 149, 217, 0, 210, 118, + 86, 211, 115, 60, 19, 124, 201, 129, 103, 17, 76, 46, 226, 149, 158, + 64, 63, 44, 184, 222, 33, 58, 204, 143, 248, 241, 138, 206, 165, 188, + 112, 6, 206, 239, 70, 18, 0, 156, 42, 177, 61, 71, 15, 22, 47, + 239, 184, 119, 62, 93, 114, 196, 215, 241, 206, 252, 57, 228, 10, 218, + 80, 89, 7, 22, 56, 81, 45, 251, 149, 124, 201, 129, 103, 17, 76, + 46, 226, 149, 158, 64, 63, 44, 184, 222, 33, 58, 204, 143, 248, 241, + 138, 206, 165, 188, 112, 6, 206, 239, 70, 18, 0, 156, 42, 177, 61, + 71, 15, 22, 47, 239, 184, 119, 62, 93, 114, 196, 215, 241, 206, 252, + 57, 228, 10, 218, 80, 89, 7, 22, 56, 81, 45, 251, 149, 47, 106, + 146, 120, 147, 159, 35, 214, 0, 249, 254, 128, 244, 234, 155, 220, 100, + 75, 113, 95, 175, 121, 196, 181, 226, 32, 155, 128, 100, 29, 203, 33, + 30, 251, 146, 72, 211, 253, 167, 86, 140, 141, 154, 48, 105, 237, 92, + 122, 34, 156, 8, 27, 211, 92, 16, 45, 250, 207, 19, 210, 128, 168, + 98, 2, 86, 93, 159, 221, 106, 148, 76, 89, 163, 97, 29, 212, 58, + 82, 55, 19, 48, 203, 35, 153, 213, 185, 150, 229, 34, 69, 203, 121, + 214, 255, 208, 17, 95, 241, 47, 41, 128, 154, 204, 17, 131, 53, 251, + 100, 244, 193, 22, 7, 77, 38, 44, 83, 35, 42, 192, 245, 37, 227, + 171, 161, 29, 45, 233, 132, 194, 175, 191, 159, 97, 234, 17, 174, 245, + 20, 41, 204, 79, 64, 12, 222, 147, 207, 135, 155, 125, 65, 78, 61, + 182, 238, 200, 105, 229, 251, 140, 136, 83, 40, 164, 240, 59, 89, 5, + 24, 221, 199, 135, 87, 62, 220, 4, 103, 49, 221, 241, 79, 214, 8, + 53, 9, 100, 232, 250, 180, 102, 254, 207, 161, 209, 52, 176, 252, 22, + 118, 14, 95, 157, 102, 44, 8, 199, 62, 33, 236, 4, 0, 50, 143, + 19, 47, 43, 243, 64, 51, 128, 47, 163, 63, 22, 36, 38, 14, 177, + 177, 104, 151, 82, 190, 124, 86, 196, 59, 158, 230, 122, 176, 151, 90, + 89, 176, 243, 116, 150, 174, 175, 117, 104, 59, 68, 183, 91, 164, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 206, 48, 30, 86, 90, 119, 9, 200, 142, 131, 133, 44, 122, 142, + 197, 197, 42, 57, 155, 91, 146, 79, 82, 138, 46, 251, 76, 9, 125, + 98, 38, 6, 214, 164, 211, 112, 182, 161, 230, 130, 248, 242, 157, 129, + 87, 180, 86, 225, 173, 171, 197, 137, 219, 67, 71, 211, 126, 158, 60, + 104, 152, 43, 247, 137, 189, 201, 226, 9, 124, 180, 76, 18, 116, 113, + 127, 246, 195, 162, 17, 123, 190, 116, 46, 254, 214, 143, 238, 239, 131, + 254, 174, 217, 196, 83, 2, 158, 135, 220, 58, 244, 249, 231, 251, 42, + 34, 199, 28, 59, 230, 181, 113, 246, 188, 88, 164, 64, 174, 147, 67, + 125, 204, 74, 51, 15, 19, 104, 161, 138, 94, 125, 131, 183, 189, 164, + 137, 242, 129, 120, 156, 222, 5, 40, 65, 63, 83, 131, 79, 104, 225, + 228, 160, 117, 167, 3, 210, 46, 189, 169, 182, 4, 251, 226, 222, 113, + 119, 63, 22, 77, 89, 95, 77, 159, 228, 254, 52, 247, 243, 48, 103, + 171, 160, 168, 181, 246, 187, 19, 179, 194, 92, 218, 41, 29, 177, 168, + 132, 163, 46, 254, 112, 246, 98, 202, 62, 247, 171, 6, 168, 142, 80, + 58, 53, 4, 253, 55, 21, 147, 179, 186, 246, 158, 10, 113, 101, 144, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 224, 25, 116, 228, 32, 209, 214, 5, 77, 135, 31, 238, 174, + 154, 191, 52, 23, 253, 66, 166, 169, 188, 81, 135, 189, 52, 105, 204, + 99, 92, 167, 14, 224, 25, 116, 228, 32, 209, 214, 5, 77, 135, 31, + 238, 174, 154, 191, 52, 23, 253, 66, 166, 169, 188, 81, 135, 189, 52, + 105, 204, 99, 92, 167, 14, 56, 56, 29, 204, 40, 17, 220, 97, 42, + 205, 220, 187, 119, 187, 204, 163, 44, 244, 148, 155, 79, 68, 245, 24, + 29, 158, 97, 27, 255, 162, 141, 15, 175, 91, 216, 161, 1, 78, 36, + 215, 123, 51, 246, 234, 230, 77, 136, 160, 198, 164, 125, 94, 140, 112, + 246, 219, 37, 232, 82, 100, 4, 43, 37, 30, 213, 142, 162, 156, 46, + 110, 179, 9, 49, 226, 65, 63, 250, 53, 32, 17, 247, 216, 218, 95, + 22, 240, 198, 3, 177, 34, 112, 142, 27, 148, 103, 6, 99, 20, 60, + 222, 99, 253, 219, 251, 60, 172, 55, 44, 171, 247, 222, 194, 45, 248, + 111, 172, 246, 69, 254, 118, 207, 3, 252, 31, 103, 252, 131, 0, 191, + 11, 115, 211, 67, 73, 172, 26, 59, 85, 55, 147, 85, 191, 138, 220, + 254, 79, 202, 240, 41, 87, 255, 207, 241, 239, 15, 120, 96, 144, 46, + 8, 217, 25, 40, 117, 147, 166, 180, 41, 29, 115, 102, 69, 13, 127, + 234, 203, 248, 115, 221, 76, 66, 47, 62, 234, 139, 224, 219, 229, 7, + 14, 231, 9, 43, 10, 75, 161, 209, 160, 92, 210, 3, 201, 217, 203, + 189, 224, 167, 31, 91, 153, 226, 92, 116, 228, 172, 222, 46, 162, 163, + 116, 64, 17, 37, 22, 56, 56, 29, 204, 40, 17, 220, 97, 42, 205, + 220, 187, 119, 187, 204, 163, 44, 244, 148, 155, 79, 68, 245, 24, 29, + 158, 97, 27, 255, 162, 141, 15, 175, 91, 216, 161, 1, 78, 36, 215, + 123, 51, 246, 234, 230, 77, 136, 160, 198, 164, 125, 94, 140, 112, 246, + 219, 37, 232, 82, 100, 4, 43, 37, 30, 213, 142, 162, 156, 46, 110, + 179, 9, 49, 226, 65, 63, 250, 53, 32, 17, 247, 216, 218, 95, 22, + 240, 198, 3, 177, 34, 112, 142, 27, 148, 103, 6, 99, 20, 60, 222, + 99, 253, 219, 251, 60, 172, 55, 44, 171, 247, 222, 194, 45, 248, 111, + 172, 246, 69, 254, 118, 207, 3, 252, 31, 103, 252, 131, 0, 191, 11, + 115, 211, 67, 73, 172, 26, 59, 85, 55, 147, 85, 191, 138, 220, 254, + 79, 202, 240, 41, 87, 255, 207, 241, 239, 15, 120, 96, 144, 46, 8, + 217, 25, 40, 117, 147, 166, 180, 41, 29, 115, 102, 69, 13, 127, 234, + 203, 248, 115, 221, 76, 66, 47, 62, 234, 139, 224, 219, 229, 7, 14, + 231, 9, 43, 10, 75, 161, 209, 160, 92, 210, 3, 201, 217, 203, 189, + 224, 167, 31, 91, 153, 226, 92, 116, 228, 172, 222, 46, 162, 163, 116, + 64, 17, 37, 22, 0, 79, 126, 134, 213, 65, 38, 253, 183, 45, 124, + 120, 201, 39, 213, 149, 99, 115, 89, 71, 80, 72, 6, 118, 212, 168, + 207, 67, 188, 68, 45, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, 85, 182, 111, 63, + 10, 2, 181, 232, 182, 255, 255, 60, 121, 30, 248, 247, 40, 192, 219, + 221, 208, 24, 248, 253, 25, 114, 114, 222, 5, 197, 23, 180, 85, 182, + 111, 63, 10, 2, 181, 232, 182, 255, 255, 60, 121, 30, 248, 247, 40, + 192, 219, 221, 208, 24, 248, 253, 25, 114, 114, 222, 5, 197, 23, 119, + 248, 38, 55, 48, 1, 131, 115, 110, 230, 206, 233, 140, 20, 188, 198, + 46, 122, 89, 24, 113, 202, 3, 105, 173, 65, 98, 115, 91, 98, 169, + 20, 196, 162, 112, 183, 132, 236, 98, 2, 23, 160, 136, 99, 152, 131, + 209, 246, 147, 169, 26, 190, 73, 63, 59, 41, 217, 199, 33, 226, 239, + 170, 72, 45, 240, 12, 58, 114, 144, 104, 235, 130, 166, 195, 15, 119, + 87, 205, 95, 154, 139, 126, 33, 211, 84, 222, 168, 195, 94, 154, 52, + 230, 49, 174, 83, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 157, 221, + 26, 10, 28, 32, 191, 101, 248, 221, 99, 216, 115, 147, 197, 181, 135, + 155, 65, 192, 215, 109, 124, 113, 176, 208, 95, 201, 119, 45, 231, 35, + 245, 49, 216, 48, 128, 234, 136, 253, 88, 14, 225, 60, 73, 204, 54, + 58, 253, 241, 91, 145, 21, 55, 188, 88, 171, 105, 155, 115, 93, 16, + 23, 40, 198, 137, 186, 79, 42, 41, 236, 55, 74, 59, 217, 61, 93, + 189, 214, 177, 90, 105, 145, 214, 141, 202, 204, 114, 215, 69, 62, 2, + 17, 163, 153, 0, 16, 222, 40, 137, 145, 0, 17, 63, 240, 95, 178, + 232, 75, 147, 181, 22, 138, 244, 132, 86, 161, 125, 23, 73, 5, 115, + 214, 107, 164, 175, 216, 44, 127, 249, 108, 88, 10, 47, 49, 49, 123, + 236, 44, 155, 1, 31, 209, 46, 143, 129, 237, 236, 116, 106, 180, 86, + 154, 167, 87, 144, 149, 106, 96, 0, 14, 109, 208, 195, 185, 74, 91, + 31, 91, 36, 72, 138, 171, 187, 47, 151, 39, 15, 203, 147, 100, 202, + 240, 189, 194, 115, 238, 179, 119, 9, 204, 28, 0, 79, 193, 133, 234, + 164, 28, 69, 60, 118, 255, 22, 211, 4, 11, 77, 156, 141, 7, 118, + 71, 182, 215, 68, 210, 114, 221, 182, 224, 83, 138, 29, 76, 227, 122, + 17, 201, 77, 115, 96, 17, 45, 84, 136, 116, 19, 243, 133, 232, 176, + 70, 177, 92, 66, 80, 31, 251, 205, 238, 27, 181, 184, 112, 4, 73, + 30, 253, 139, 5, 43, 227, 168, 109, 151, 130, 89, 190, 178, 163, 78, + 102, 172, 194, 189, 209, 103, 228, 178, 85, 251, 32, 239, 114, 24, 176, + 33, 231, 35, 174, 168, 44, 7, 25, 108, 40, 137, 206, 28, 76, 136, + 92, 37, 9, 151, 40, 116, 89, 254, 245, 139, 167, 51, 210, 176, 118, + 26, 187, 12, 100, 247, 13, 35, 56, 203, 156, 115, 237, 57, 80, 166, + 8, 222, 169, 126, 204, 182, 84, 83, 64, 173, 187, 202, 62, 134, 140, + 245, 61, 199, 139, 9, 176, 255, 211, 202, 200, 48, 152, 98, 50, 13, + 116, 157, 176, 103, 37, 143, 64, 142, 98, 142, 105, 197, 253, 132, 144, + 153, 219, 206, 6, 189, 247, 27, 242, 106, 140, 82, 187, 125, 126, 219, + 249, 30, 96, 121, 151, 111, 31, 115, 3, 62, 28, 1, 4, 25, 128, + 82, 238, 208, 117, 29, 66, 133, 38, 45, 100, 17, 97, 61, 200, 143, + 244, 45, 143, 152, 144, 33, 218, 74, 105, 38, 72, 9, 133, 174, 79, + 214, 125, 150, 237, 31, 49, 172, 163, 99, 18, 33, 101, 105, 179, 120, + 117, 109, 166, 142, 59, 229, 87, 120, 60, 135, 191, 117, 8, 103, 12, + 195, 56, 132, 26, 222, 198, 204, 193, 115, 171, 231, 24, 8, 96, 238, + 75, 121, 1, 167, 198, 41, 172, 68, 151, 250, 1, 44, 86, 128, 206, + 216, 51, 222, 212, 98, 27, 110, 233, 71, 237, 2, 128, 230, 207, 47, + 138, 81, 37, 232, 233, 89, 105, 92, 81, 156, 240, 130, 7, 66, 42, + 116, 26, 150, 84, 0, 180, 200, 40, 107, 113, 195, 112, 201, 97, 15, + 151, 39, 209, 156, 244, 230, 255, 38, 129, 86, 158, 222, 187, 114, 12, + 181, 165, 195, 133, 203, 82, 73, 89, 193, 31, 65, 90, 78, 115, 243, + 157, 8, 125, 43, 215, 36, 59, 56, 30, 17, 50, 13, 195, 199, 252, + 64, 168, 196, 47, 181, 14, 233, 139, 195, 85, 215, 82, 200, 121, 150, + 89, 171, 71, 244, 111, 43, 121, 149, 116, 179, 150, 19, 148, 104, 193, + 122, 100, 213, 72, 25, 176, 136, 51, 215, 204, 65, 127, 79, 129, 230, + 165, 96, 102, 106, 115, 82, 185, 41, 80, 100, 75, 128, 110, 248, 191, + 167, 2, 14, 217, 16, 102, 229, 244, 37, 41, 18, 170, 68, 121, 204, + 200, 160, 28, 14, 105, 198, 121, 160, 80, 12, 77, 237, 60, 17, 219, + 241, 70, 130, 57, 143, 232, 158, 109, 62, 203, 12, 27, 180, 198, 94, + 185, 114, 86, 39, 64, 51, 63, 130, 33, 13, 194, 2, 210, 181, 171, + 186, 18, 196, 12, 44, 2, 205, 59, 176, 243, 5, 116, 241, 191, 239, + 243, 71, 40, 163, 75, 83, 118, 170, 19, 254, 172, 201, 108, 19, 60, + 185, 137, 81, 236, 3, 252, 167, 82, 77, 246, 179, 98, 95, 209, 52, + 68, 24, 134, 5, 114, 62, 184, 182, 176, 108, 112, 91, 177, 35, 130, + 5, 54, 180, 181, 23, 114, 97, 66, 229, 50, 14, 50, 124, 141, 158, + 228, 154, 99, 114, 204, 235, 243, 212, 110, 60, 26, 207, 151, 83, 239, + 1, 33, 28, 155, 148, 140, 240, 81, 215, 214, 13, 83, 7, 16, 186, + 2, 41, 213, 132, 217, 47, 22, 4, 21, 63, 240, 58, 212, 125, 213, + 220, 205, 42, 98, 11, 159, 155, 209, 143, 126, 80, 228, 149, 61, 63, + 201, 96, 161, 3, 116, 53, 245, 166, 234, 2, 237, 112, 220, 210, 160, + 140, 64, 15, 30, 172, 218, 18, 67, 124, 200, 51, 190, 15, 38, 255, + 39, 117, 117, 76, 102, 131, 229, 184, 75, 159, 140, 167, 49, 129, 230, + 183, 244, 55, 203, 44, 186, 59, 74, 23, 114, 53, 49, 160, 157, 235, + 65, 66, 72, 121, 165, 15, 115, 202, 178, 31, 236, 98, 174, 141, 135, + 22, 238, 113, 127, 88, 60, 13, 255, 117, 41, 42, 200, 98, 195, 53, + 53, 74, 149, 199, 97, 54, 220, 234, 252, 202, 175, 207, 3, 59, 87, + 232, 6, 201, 128, 114, 84, 40, 191, 82, 45, 28, 233, 35, 54, 180, + 181, 23, 114, 97, 66, 229, 50, 14, 50, 124, 141, 158, 228, 154, 99, + 114, 204, 235, 243, 212, 110, 60, 26, 207, 151, 83, 239, 1, 33, 28, + 210, 202, 99, 140, 166, 155, 145, 194, 225, 197, 238, 153, 186, 17, 115, + 109, 94, 2, 189, 225, 78, 171, 188, 57, 14, 249, 199, 42, 151, 11, + 203, 7, 176, 99, 169, 165, 178, 31, 218, 246, 29, 188, 175, 204, 219, + 109, 5, 201, 61, 127, 43, 108, 132, 137, 248, 149, 97, 144, 197, 163, + 70, 42, 174, 7, 67, 124, 200, 51, 190, 15, 38, 255, 39, 117, 117, + 76, 102, 131, 229, 184, 75, 159, 140, 167, 49, 129, 230, 183, 244, 55, + 203, 44, 186, 59, 74, 23, 171, 189, 25, 161, 158, 122, 145, 168, 45, + 116, 250, 2, 247, 245, 29, 139, 125, 170, 187, 71, 106, 248, 255, 247, + 114, 177, 237, 224, 136, 186, 24, 41, 22, 254, 190, 120, 173, 181, 38, + 177, 252, 50, 71, 108, 23, 9, 188, 24, 97, 154, 245, 232, 219, 48, + 113, 2, 248, 3, 196, 239, 97, 240, 185, 131, 32, 174, 197, 215, 143, + 159, 111, 38, 61, 146, 149, 72, 78, 61, 21, 77, 59, 221, 27, 238, + 186, 215, 125, 135, 213, 56, 38, 210, 30, 68, 18, 166, 145, 24, 247, + 46, 127, 129, 145, 94, 70, 227, 105, 222, 152, 58, 159, 60, 155, 107, + 169, 171, 23, 130, 185, 202, 202, 29, 46, 149, 14, 162, 221, 39}; + + constexpr static Point kAdviceCommitments[][5] = { + {{"0x21b657ef880458c04e6f90cb1d52d99e3c4f275f62463f91316ce6e89a7727b0", + "0x018e7e556102c958d925644e9fdec38e1b6c88572a98ce9871485937ff5c9aa4"}, + {"0x1cdeebb09fa825fe5ee9bd16d16ddb62866f26077a8607f5be81f7f45ac3606f", + "0x0dd225bfadd39c83ca40e0a578ae098e3dce0b62b8bbf3445e63fe035c71ce09"}, + {"0x1422edcd2b94cb798037fed6eee6061495ef3679ec4f9d89edda2e6f9ef299eb", + "0x07aff8c1c8c754b022575c2e7e2f98483f08111f3dc0a9d7e2b119c5063c97b9"}, + {"0x26d69af68d0081752eb20fba0c186241da3677528ef11c81c234981b9feb7768", + "0x0cb675234a966e9b7fe6f87c6da86e5b3d534330dd6ebc08302da54ccee2352f"}, + {"0x133c73d35676d200d9951b8a8cdd8719fc73de2bf26dcd8246efb8137e90c635", + "0x1eb2849fbface2516b2dfa0d9ed2ec2b397a04ae228a2541d32bc83bb429de30"}}, + {{"0x21b657ef880458c04e6f90cb1d52d99e3c4f275f62463f91316ce6e89a7727b0", + "0x018e7e556102c958d925644e9fdec38e1b6c88572a98ce9871485937ff5c9aa4"}, + {"0x1cdeebb09fa825fe5ee9bd16d16ddb62866f26077a8607f5be81f7f45ac3606f", + "0x0dd225bfadd39c83ca40e0a578ae098e3dce0b62b8bbf3445e63fe035c71ce09"}, + {"0x1422edcd2b94cb798037fed6eee6061495ef3679ec4f9d89edda2e6f9ef299eb", + "0x07aff8c1c8c754b022575c2e7e2f98483f08111f3dc0a9d7e2b119c5063c97b9"}, + {"0x26d69af68d0081752eb20fba0c186241da3677528ef11c81c234981b9feb7768", + "0x0cb675234a966e9b7fe6f87c6da86e5b3d534330dd6ebc08302da54ccee2352f"}, + {"0x133c73d35676d200d9951b8a8cdd8719fc73de2bf26dcd8246efb8137e90c635", + "0x1eb2849fbface2516b2dfa0d9ed2ec2b397a04ae228a2541d32bc83bb429de30"}}}; + + constexpr static std::string_view kTheta = + "0x1950defb9d8f3478e0462ac34605c6e7e42bd2b2b7b3fba3f26ccf52d8cdd3d9"; + + constexpr static Point kLookupMPolyCommitments[][2] = { + {{"0x001246efce0670bca5ce8af1f88fcc3a21deb82c3f409e95e22e4c116781c97c", + "0x1de4836417d97b2def8418f351899aa9e5de200cac99f0bcb36f03b44c2fbb8e"}, + {"0x15fb2d513816075950da0ae439fccef1d7c4725d3e77b8ef2f160f473db12a9c", + "0x13a5bf0b4bde809ec00d335afbfb4ee7d1a01b17d5f6ba51b353be98ac7034cb"}}, + {{"0x001246efce0670bca5ce8af1f88fcc3a21deb82c3f409e95e22e4c116781c97c", + "0x1de4836417d97b2def8418f351899aa9e5de200cac99f0bcb36f03b44c2fbb8e"}, + {"0x15fb2d513816075950da0ae439fccef1d7c4725d3e77b8ef2f160f473db12a9c", + "0x13a5bf0b4bde809ec00d335afbfb4ee7d1a01b17d5f6ba51b353be98ac7034cb"}}}; + + constexpr static std::string_view kBeta = + "0x23f0ccec89984730d17a9c88a90ccd1d6bee9ed2442135be437b4eec2efdf4e5"; + + constexpr static std::string_view kGamma = + "0x2ff50b653ed88cfd62881c0808ab7cfe4022979bbfa9fc630abf3314376ff72f"; + + constexpr static Point kPermutationProductCommitments[][2] = { + {{"0x21cb1d64809b20e2b5c479af5f714b64dc9beaf480fef900d6239f9378926a2f", + "0x214dde853e3cc035c05c8b84bcf86c43166fe9ccbe83afbae279af986509d8e6"}, + {"0x0262a880d213cffa2d105cd31b089c227a5ced69309a8d8c56a7fdd34892fb1e", + "0x2853361cd32d728b82f8707b858c329db9030303f2f19a96f13f578a11e86288"}}, + {{"0x11d0ffd679cb4522e596b9d59923cb301337523ad41d61a3594c946add9f5d56", + "0x274c1e9923844c2e26d5ebd1185c7b3f435793c97be850f71a5c9cea1c9d7dfc"}, + {"0x04e92d1da1abe325f5c02a23532c264d0716c1f464fb358311cc9a80292ff15f", + "0x1413f36166810082edec8b75bb4394035e805bdd7c55081f4daf484176907039"}}}; + + constexpr static Point kLookupSumCommitments[][2] = { + {{"0x088cfbe569c8eeb63d4e417d9b87cf93de0c404fcc2914f5ae11ea619fbfafc2", + "0x03471f2d881f2217d06572ea016ae29248c4aec5f0b6b9323bd1a874495b732d"}, + {"0x21cffe66b4fae864093508d64ff1dd316704dc3e5787c7dd1805593bf0a42853", + "0x1c6979a305b27a1c4fbacb790d448374ddcbf7d6d34babd107aadec9f77bb387"}}, + {{"0x24163fa32f803340f32b2f138f320004ec213ec7082c669d5f0e7616fcb034d1", + "0x2245605a921ee4129a8afc4470b7fe09d1b6828b79554809062d78d03c927d48"}, + {"0x245bb7443b6875afae9674f3b0595a97b07ae69e3bc4567cbe529768b1b10e26", + "0x0f50cbd07e4c6324943fb67e5152fe744f0a743db0f3a916d8b0aefbba5562d7"}}}; + + constexpr static std::string_view kY = + "0x14a11aa54972e4ccc124d864294cf931f0dc03ac7a2ec95b0f0ac3cc12f4084c"; + + constexpr static Point kVanishingHPolyCommitments[] = { + {"0x0626627d094cfb2e8a524f925b9b392ac5c58e7a2c85838ec809775a561e30ce", + "0x027475498093bb8980162e07443c687470b8c733e662c2f0e4ef5f02258eea7e"}, + {"0x09f72b98683c9e7ed34743db89c5abade156b457819df2f882e6a1b670d3a4d6", + "0x1140fae51df608d6a2547478b832f1c432f64001a5489821b51931ae5514e90b"}, + {"0x1e0253c4d9aefe83efee8fd6fe2e74be7b11a2c3f67f7174124cb47c09e2c9bd", + "0x0a94c3680633c6de8c2cc21b2b2084be9d762c2f5a70daec2e8652c636331419"}, + {"0x0aa168130f334acc7d4393ae40a458bcf671b5e63b1cc7222afbe7f9f43adc87", + "0x303d390350ba67188ea70e143b97e801a239ea461966b439e0d9f3c3fe7625ed"}, + {"0x04b6a9bd2ed203a775a0e4e1684f83533f412805de9c7881f289a4bdb7837d5e", + "0x01436523c447e9c964c05f20010edc4cf17fcfc233d205d5bf9303e8aab4fa24"}, + {"0x1d29da5cc2b313bbf6b5a8a0ab6730f3f734fee49f4d5f594d163f7771dee2fb", + "0x277ee0d97e88815831a9b0a07bbaa43f96beb8e722261626fd3dd4a177702032"}, + {"0x1065710a9ef6bab3931537fd04353a508ea806abf73eca62f670fe2ea384a8b1", + "0x2097a981e1c19363797e45b9c162994a9585e3c7f7fe11d1cf814a6bec1f1ec7"}, + {"0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000"}}; + + constexpr static std::string_view kX = + "0x215e6d5668ce2312f91197fea89b859a52c502e76fa5f3326c6e9e43ba5a0655"; + + constexpr static std::string_view kAdviceEvals[][7] = { + {"0x0f8da2ff1b619e1d18f5444f9b94f42ca3ccbb77bbdccd2a61dc1128cc1d3838", + "0x1e252b046452e825dbf6708c5e7da4c6a0884de6eaf6337bd7244e01a1d85baf", + "0x0667941b8e7022b103c6f0165fdad8f7112035fa3f41e23109b36e2e9ca28ed5", + "0x0083fc671ffc03cf76fe45f6ac6ff82dc2def7ab2c37ac3cfbdbfd63de3c1463", + "0x082e9060780feff1cfff5729f0ca4ffedc8abf559337553b1aac4943d3730bbf", + "0x09e70e07e5dbe08bea3e2f424cdd73f8cbea7f0d4566731d29b4a693752819d9", + "0x1625114074a3a22edeace4745ce2995b1fa7e0bdcbd9c903d25ca0d1a14b0a2b"}, + {"0x0f8da2ff1b619e1d18f5444f9b94f42ca3ccbb77bbdccd2a61dc1128cc1d3838", + "0x1e252b046452e825dbf6708c5e7da4c6a0884de6eaf6337bd7244e01a1d85baf", + "0x0667941b8e7022b103c6f0165fdad8f7112035fa3f41e23109b36e2e9ca28ed5", + "0x0083fc671ffc03cf76fe45f6ac6ff82dc2def7ab2c37ac3cfbdbfd63de3c1463", + "0x082e9060780feff1cfff5729f0ca4ffedc8abf559337553b1aac4943d3730bbf", + "0x09e70e07e5dbe08bea3e2f424cdd73f8cbea7f0d4566731d29b4a693752819d9", + "0x1625114074a3a22edeace4745ce2995b1fa7e0bdcbd9c903d25ca0d1a14b0a2b"}}; + + constexpr static std::string_view kFixedEvals[] = { + "0x092d44bc43cfa8d4760648504759736395d527c9787c2db7fd2641d5867e4f00", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x17c505de727219fdf818d0dddbc028f7f81e793cffffb6e8b5020a3f6fb655b4", + "0x17c505de727219fdf818d0dddbc028f7f81e793cffffb6e8b5020a3f6fb655b4", + "0x14a9625b736241ad6903ca7118597a2ec6bc148ce9cee66e738301303726f877", + "0x2d48aaefe221c7d9293b3f49be1aa993f6d183986388a0170262ec84b770a2c4", + "0x0753ae31e6349a5ec3a8de54d3217e8b9a5fcd57770fc3a682eb6890723a0cf0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000"}; + + constexpr static std::string_view kCommonPermutationEvals[] = { + "0x23e72d77c95fd0b0717c6dd7c0419b87b5c59373d863ddf865bf201c0a1add9d", + "0x2817105d739b69ab58bc3715915bf1fd3a36cc493ce10e58fd88ea8030d831f5", + "0x0099a311023e45d772ccca8dd691695ab1d6bd5d3dd93b4a37ec292a4fba89c6", + "0x2cd8afa46bd6730549177da15684f48a16b5934be8b25ff03f1100918928de10", + "0x00606a959057a79a56b46a74eced818f2ed11f019b2cec7b31312f0a586cf97f", + "0x1ccc0977b3ee73c2bdf0ca6493cb0f27972fbbab8a48245b1f5b4ab9c3d06d0e", + "0x1d8a53e0b6dd72d244d7b64776078d9c4d0b04d316ff763c451ca4ea85c14f00", + "0x0470b8b51beecdfb1f50425cb146b0e885f3137488542d1160734dc9117ae34c", + "0x21b01872ef20fb55b2e467d1bdc2ac664ea3b2be5982976da8e32b058bfd1e49", + "0x0cbb1a76b0d233a78bf5fe5974289709255c884c1cce89286c19072ca8ae23e7", + "0x098bc73df58c863ecabbad405354b6cc7ea9de08a65039ed739ccb38230df764", + "0x1bf7bd06cedb999084fdc5698e628e408f2567b09d740d32629830c8cad3ffb0"}; + + constexpr static std::string_view kPermutationProductEvals[][2] = { + {"0x2d2685421d75d0ee52801904011c3e03731f6f9779601ef9db7e7dbb528c6af2", + "0x2fcfe68002ed47e96e1b62d4de33d8ce80562c01fa9744ac29c6a701794bee60"}, + {"0x2b7d089df3734e5a411fc1594952cb85c3a5b50c72bbde9e568126ffe6f49cd1", + "0x0c50a079c6690e1ca0c8cc7944aa122925f4e56610d90e02a7bff86e804b6450"}}; + + constexpr static std::string_view kLookupSumEvals[][2] = { + {"0x136cc9acfe13aa76534ba32847f3efbff17405f3b03bcd022c0cc412baabb5d2", + "0x0b622acddcd57dd43af03f1504162fd984d52902ba1007530dd6d751f08c949b"}, + {"0x2a2975ff0d3c587f71ee16878dae62ec1fb2ca730fa579484241eb9da0313572", + "0x07cb0b972ac7f90e39bcab4ee1bd025e6d7311ba99eec5e1c2919ba68c63cad2"}}; + + constexpr static std::string_view kPermutationProductNextEvals[][2] = { + {"0x211263a3ac311fed967dd64fae85094826694ada2190988f2df48fc83d611164", + "0x27970f61c970c3716b28c8b40054961a742a420782f09c515c6959e9e825518a"}, + {"0x2b6ff447ab599679c852d755c38be90eb52fc4a840fcc7c30d32111e383b24d7", + "0x02c20d21823f3340275672b95ec6b41b0ccb3e6d9ee88f398246f1db113ced4d"}}; + + constexpr static std::string_view kLookupSumNextEvals[][2] = { + {"0x058223b15b706cb0b6b83e720586184434d15f62b3f64d52a7fc03ec5189b93c", + "0x12daac1e0f408ca0d2dc70ed02eaa6f5357403a160c93f3d95e4507e8fd19b9f"}, + {"0x23e91c2d52bf28547280c906e8573b03cfafcafceadc3661c7954a3535c362c8", + "0x07ae2a46a3c5906195f889846c2b7f3dc9056ddbccafbc1df6da1fb2a5a963b0"}}; + + constexpr static std::string_view kPermutationProductLastEvals[][2] = { + {"0x0818e7ab73c1ccc6de1a8438c30c670875bf873c7857e53b8ea66d7578b36965", + ""}, + {"0x29b952736a6660a5e6814f7f41ccd73388b01948d5647ac168941396b3749579", + ""}}; + + constexpr static std::string_view kLookupMEvals[][2] = { + {"0x1c2101ef5397cf1a3c6ed4f3ebcc72639ae49e8d7c320e32e542617217b5b436", + "0x174a3bba2ccb37f4b7e68131a78c9f4bb8e583664c757527ff260fbe33c87c43"}, + {"0x1c2101ef5397cf1a3c6ed4f3ebcc72639ae49e8d7c320e32e542617217b5b436", + "0x174a3bba2ccb37f4b7e68131a78c9f4bb8e583664c757527ff260fbe33c87c43"}}; + + constexpr static std::string_view kHEval = + "0x2cd9193f90b95f467e30b04eaf9323729ce11213a75de146903ea1e4fb89aa85"; + + static void TestConfig(MultiLookupCircuitConfig& config) {} + + static Circuit GetCircuit() { + F a = *F::FromHexString( + "0x76a69c75ed45f60e667fb401dd42f877b565f7818b1d94188fb67249"); + F instance = F(2); + std::vector lookup_table = {instance, a, a, F::Zero()}; + return Circuit(std::move(a), std::move(lookup_table)); + } + + static std::vector Get2Circuits() { + Circuit circuit = GetCircuit(); + return {circuit, std::move(circuit)}; + } + + static std::vector GetInstanceColumns() { + F instance = F(2); + std::vector instance_column = {std::move(instance)}; + return {Evals(std::move(instance_column))}; + } +}; + +} // namespace tachyon::zk::plonk + +#endif // TACHYON_ZK_PLONK_EXAMPLES_MULTI_LOOKUP_CIRCUIT_TEST_DATA_H_