Skip to content

Commit 946f950

Browse files
dbanks12iAmMichaelConnorsuyash67
committed
test: more vk tests to compare circuit/native/vk_data (#310)
* align native and circuit vk hashing methods * fix: pass hash_index to circuit vk function * add some of the composer_type/plookup toggling for vk compress. Add some vk/eval-domain comments * rename key_witnesses->preimage_data and composer type compression to circuit-compress of recursion vk * some native verification_key_data tests * Mc/hash vk (#306) * align native and circuit vk hashing methods * fix: pass hash_index to circuit vk function * add some of the composer_type/plookup toggling for vk compress. Add some vk/eval-domain comments * rename key_witnesses->preimage_data and composer type compression to circuit-compress of recursion vk * some native verification_key_data tests * add native and recursive vk compress test. * change test name. --------- Co-authored-by: dbanks12 <david@aztecprotocol.com> Co-authored-by: Suyash Bagad <suyashnbagad1997@gmail.com> * verification key tests * inc num_generators_per_hash_index to 128. (#309) * revert bad changes to eval domain * add vk recursion tests to CI, remove old info in vk test * Remove new CI job in config.yml --------- Co-authored-by: iAmMichaelConnor <mike@aztecprotocol.com> Co-authored-by: Suyash Bagad <suyashnbagad1997@gmail.com> Co-authored-by: Suyash Bagad <suyash@aztecprotocol.com>
1 parent 22d37b0 commit 946f950

File tree

2 files changed

+164
-107
lines changed

2 files changed

+164
-107
lines changed

‎cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.test.cpp

+73-74
Original file line numberDiff line numberDiff line change
@@ -5,153 +5,152 @@
55

66
namespace {
77
auto& engine = numeric::random::get_debug_engine();
8-
}
8+
} // namespace
99

1010
using namespace barretenberg;
1111
using namespace proof_system::plonk;
1212

1313
namespace proof_system::plonk::test_verification_key {
1414

1515
/**
16-
* @brief generated a random vk data for use in tests
16+
* @brief generate a random vk data for use in tests
1717
*
1818
* @return verification_key_data randomly generated
1919
*/
20-
verification_key_data rand_vk_data()
21-
{
22-
verification_key_data key_data;
23-
key_data.composer_type = static_cast<uint32_t>(proof_system::ComposerType::STANDARD);
24-
key_data.circuit_size = 1024; // not random - must be power of 2
25-
key_data.num_public_inputs = engine.get_random_uint32();
26-
key_data.commitments["test1"] = g1::element::random_element();
27-
key_data.commitments["test2"] = g1::element::random_element();
28-
key_data.commitments["foo1"] = g1::element::random_element();
29-
key_data.commitments["foo2"] = g1::element::random_element();
30-
return key_data;
20+
verification_key_data rand_vk_data() {
21+
verification_key_data vk_data;
22+
vk_data.composer_type = static_cast<uint32_t>(proof_system::ComposerType::STANDARD);
23+
vk_data.circuit_size = 1024; // not random - must be power of 2
24+
vk_data.num_public_inputs = engine.get_random_uint32();
25+
vk_data.commitments["test1"] = g1::element::random_element();
26+
vk_data.commitments["test2"] = g1::element::random_element();
27+
vk_data.commitments["foo1"] = g1::element::random_element();
28+
vk_data.commitments["foo2"] = g1::element::random_element();
29+
return vk_data;
3130
}
3231

3332
/**
3433
* @brief expect that two vk data compressions are equal for a few different hash indices
3534
*
36-
* @param key0_data
37-
* @param key1_data
35+
* @param vk0_data
36+
* @param vk1_data
3837
*/
39-
void expect_compressions_eq(verification_key_data key0_data, verification_key_data key1_data)
38+
void expect_compressions_eq(verification_key_data vk0_data, verification_key_data vk1_data)
4039
{
4140
// 0 hash index
42-
EXPECT_EQ(key0_data.compress_native(0), key1_data.compress_native(0));
41+
EXPECT_EQ(vk0_data.compress_native(0), vk1_data.compress_native(0));
4342
// nonzero hash index
44-
EXPECT_EQ(key0_data.compress_native(15), key1_data.compress_native(15));
43+
EXPECT_EQ(vk0_data.compress_native(15), vk1_data.compress_native(15));
4544
}
4645

4746
/**
4847
* @brief expect that two vk data compressions are not-equal for a few different hash indices
4948
*
50-
* @param key0_data
51-
* @param key1_data
49+
* @param vk0_data
50+
* @param vk1_data
5251
*/
53-
void expect_compressions_ne(verification_key_data key0_data, verification_key_data key1_data)
52+
void expect_compressions_ne(verification_key_data vk0_data, verification_key_data vk1_data)
5453
{
55-
EXPECT_NE(key0_data.compress_native(0), key1_data.compress_native(0));
56-
EXPECT_NE(key0_data.compress_native(15), key1_data.compress_native(15));
57-
// ne hash indeces still lead to ne compressions
58-
EXPECT_NE(key0_data.compress_native(0), key1_data.compress_native(15));
59-
EXPECT_NE(key0_data.compress_native(14), key1_data.compress_native(15));
54+
EXPECT_NE(vk0_data.compress_native(0), vk1_data.compress_native(0));
55+
EXPECT_NE(vk0_data.compress_native(15), vk1_data.compress_native(15));
56+
// ne hash indices still lead to ne compressions
57+
EXPECT_NE(vk0_data.compress_native(0), vk1_data.compress_native(15));
58+
EXPECT_NE(vk0_data.compress_native(14), vk1_data.compress_native(15));
6059
}
6160

6261
TEST(verification_key, buffer_serialization)
6362
{
64-
verification_key_data key_data = rand_vk_data();
63+
verification_key_data vk_data = rand_vk_data();
6564

66-
auto buf = to_buffer(key_data);
65+
auto buf = to_buffer(vk_data);
6766
auto result = from_buffer<verification_key_data>(buf);
6867

69-
EXPECT_EQ(key_data, result);
68+
EXPECT_EQ(vk_data, result);
7069
}
7170

7271
TEST(verification_key, stream_serialization)
7372
{
74-
verification_key_data key_data = rand_vk_data();
73+
verification_key_data vk_data = rand_vk_data();
7574

7675
std::stringstream s;
77-
write(s, key_data);
76+
write(s, vk_data);
7877

7978
verification_key_data result;
8079
read(static_cast<std::istream&>(s), result);
8180

82-
EXPECT_EQ(key_data, result);
81+
EXPECT_EQ(vk_data, result);
8382
}
8483

8584
TEST(verification_key, basic_compression_equality)
8685
{
87-
verification_key_data key0_data = rand_vk_data();
88-
verification_key_data key1_data = key0_data; // copy
89-
expect_compressions_eq(key0_data, key1_data);
86+
verification_key_data vk0_data = rand_vk_data();
87+
verification_key_data vk1_data = vk0_data; // copy
88+
expect_compressions_eq(vk0_data, vk1_data);
9089
}
9190

9291
TEST(verification_key, compression_inequality_index_mismatch)
9392
{
94-
verification_key_data key0_data = rand_vk_data();
95-
verification_key_data key1_data = key0_data; // copy
93+
verification_key_data vk0_data = rand_vk_data();
94+
verification_key_data vk1_data = vk0_data; // copy
9695
// inquality on hash index mismatch
97-
EXPECT_NE(key0_data.compress_native(0), key1_data.compress_native(15));
98-
EXPECT_NE(key0_data.compress_native(14), key1_data.compress_native(15));
96+
EXPECT_NE(vk0_data.compress_native(0), vk1_data.compress_native(15));
97+
EXPECT_NE(vk0_data.compress_native(14), vk1_data.compress_native(15));
9998
}
10099

101100
TEST(verification_key, compression_inequality_composer_type)
102101
{
103-
verification_key_data key0_data = rand_vk_data();
104-
verification_key_data key1_data = key0_data; // copy
105-
key0_data.composer_type = static_cast<uint32_t>(proof_system::ComposerType::PLOOKUP);
106-
expect_compressions_ne(key0_data, key1_data);
102+
verification_key_data vk0_data = rand_vk_data();
103+
verification_key_data vk1_data = vk0_data; // copy
104+
vk0_data.composer_type = static_cast<uint32_t>(proof_system::ComposerType::PLOOKUP);
105+
expect_compressions_ne(vk0_data, vk1_data);
107106
}
108107

109-
TEST(verification_key, compression_inequality_different_circuit_size)
108+
TEST(verification_key, compression_inequality_different_circuit_size) \
110109
{
111-
verification_key_data key0_data = rand_vk_data();
112-
verification_key_data key1_data = key0_data;
113-
key0_data.circuit_size = 4096;
114-
expect_compressions_ne(key0_data, key1_data);
110+
verification_key_data vk0_data = rand_vk_data();
111+
verification_key_data vk1_data = vk0_data;
112+
vk0_data.circuit_size = 4096;
113+
expect_compressions_ne(vk0_data, vk1_data);
115114
}
116115

117-
TEST(verification_key, compression_inequality_different_num_public_inputs)
116+
TEST(verification_key, compression_inequality_different_num_public_inputs) \
118117
{
119-
verification_key_data key0_data = rand_vk_data();
120-
verification_key_data key1_data = key0_data;
121-
key0_data.num_public_inputs = 42;
122-
expect_compressions_ne(key0_data, key1_data);
118+
verification_key_data vk0_data = rand_vk_data();
119+
verification_key_data vk1_data = vk0_data;
120+
vk0_data.num_public_inputs = 42;
121+
expect_compressions_ne(vk0_data, vk1_data);
123122
}
124123

125-
TEST(verification_key, compression_inequality_different_commitments)
124+
TEST(verification_key, compression_inequality_different_commitments) \
126125
{
127-
verification_key_data key0_data = rand_vk_data();
128-
verification_key_data key1_data = key0_data;
129-
key0_data.commitments["test1"] = g1::element::random_element();
130-
expect_compressions_ne(key0_data, key1_data);
126+
verification_key_data vk0_data = rand_vk_data();
127+
verification_key_data vk1_data = vk0_data;
128+
vk0_data.commitments["test1"] = g1::element::random_element();
129+
expect_compressions_ne(vk0_data, vk1_data);
131130
}
132131

133-
TEST(verification_key, compression_inequality_different_num_commitments)
132+
TEST(verification_key, compression_inequality_different_num_commitments) \
134133
{
135-
verification_key_data key0_data = rand_vk_data();
136-
verification_key_data key1_data = key0_data;
137-
key0_data.commitments["new"] = g1::element::random_element();
138-
expect_compressions_ne(key0_data, key1_data);
134+
verification_key_data vk0_data = rand_vk_data();
135+
verification_key_data vk1_data = vk0_data;
136+
vk0_data.commitments["new"] = g1::element::random_element();
137+
expect_compressions_ne(vk0_data, vk1_data);
139138
}
140139

141-
TEST(verification_key, compression_equality_different_contains_recursive_proof)
140+
TEST(verification_key, compression_equality_different_contains_recursive_proof) \
142141
{
143-
verification_key_data key0_data = rand_vk_data();
144-
verification_key_data key1_data = key0_data;
145-
key0_data.contains_recursive_proof = false;
146-
key1_data.contains_recursive_proof = true;
147-
expect_compressions_eq(key0_data, key1_data);
142+
verification_key_data vk0_data = rand_vk_data();
143+
verification_key_data vk1_data = vk0_data;
144+
vk0_data.contains_recursive_proof = false;
145+
vk1_data.contains_recursive_proof = true;
146+
expect_compressions_eq(vk0_data, vk1_data);
148147
}
149148

150-
TEST(verification_key, compression_equality_different_recursive_proof_public_input_indices)
149+
TEST(verification_key, compression_equality_different_recursive_proof_public_input_indices) \
151150
{
152-
verification_key_data key0_data = rand_vk_data();
153-
verification_key_data key1_data = key0_data;
154-
key1_data.recursive_proof_public_input_indices.push_back(42);
155-
expect_compressions_eq(key0_data, key1_data);
151+
verification_key_data vk0_data = rand_vk_data();
152+
verification_key_data vk1_data = vk0_data;
153+
vk1_data.recursive_proof_public_input_indices.push_back(42);
154+
expect_compressions_eq(vk0_data, vk1_data);
156155
}
157156
} // namespace proof_system::plonk::test_verification_key

‎cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp

+91-33
Original file line numberDiff line numberDiff line change
@@ -1,42 +1,100 @@
1-
#include "verification_key.hpp"
2-
#include <gtest/gtest.h>
3-
4-
#include "barretenberg/ecc/curves/bn254/fr.hpp"
5-
#include "barretenberg/ecc/curves/bn254/g1.hpp"
1+
#include "barretenberg/common/test.hpp"
62
#include "barretenberg/proof_system/verification_key/verification_key.hpp"
7-
#include "barretenberg/plonk/proof_system/constants.hpp"
8-
#include "barretenberg/stdlib/types/types.hpp"
9-
10-
using namespace plonk;
3+
#include "barretenberg/plonk/composer/standard_composer.hpp"
4+
#include "barretenberg/plonk/composer/turbo_composer.hpp"
5+
#include "barretenberg/plonk/composer/ultra_composer.hpp"
6+
#include "verification_key.hpp"
117

128
namespace {
139
auto& engine = numeric::random::get_debug_engine();
14-
}
10+
} // namespace
11+
12+
/**
13+
* @brief A test fixture that will let us generate VK data and run tests
14+
* for all composer types
15+
*
16+
* @tparam Composer
17+
*/
18+
template <typename Composer> class VerificationKeyFixture : public testing::Test {
19+
public:
20+
using Curve = stdlib::bn254<Composer>;
21+
using RecursVk = plonk::stdlib::recursion::verification_key<Curve>;
22+
23+
static Composer init_composer() {
24+
return Composer("../srs_db/ignition");
25+
}
26+
27+
/**
28+
* @brief generate a random vk data for use in tests
29+
*
30+
* @return verification_key_data randomly generated
31+
*/
32+
static verification_key_data rand_vk_data() {
33+
verification_key_data vk_data;
34+
vk_data.composer_type = static_cast<uint32_t>(Composer::type);
35+
vk_data.circuit_size = 1024; // not random - must be power of 2
36+
vk_data.num_public_inputs = engine.get_random_uint32();
37+
vk_data.commitments["test1"] = g1::element::random_element();
38+
vk_data.commitments["test2"] = g1::element::random_element();
39+
vk_data.commitments["foo1"] = g1::element::random_element();
40+
vk_data.commitments["foo2"] = g1::element::random_element();
41+
return vk_data;
42+
}
43+
};
44+
45+
// Each test will run for all composer types
46+
using ComposerTypes = testing::Types<plonk::StandardComposer, plonk::TurboComposer, plonk::UltraComposer, honk::StandardHonkComposer>;
47+
TYPED_TEST_SUITE(VerificationKeyFixture, ComposerTypes);
1548

16-
verification_key_data rand_vk_data(plonk::ComposerType composer_type)
49+
TYPED_TEST(VerificationKeyFixture, vk_data_vs_recursion_compress_native)
1750
{
18-
verification_key_data key_data;
19-
key_data.composer_type = static_cast<uint32_t>(composer_type);
20-
key_data.circuit_size = 1024; // not random - must be power of 2
21-
key_data.num_public_inputs = engine.get_random_uint16();
22-
key_data.commitments["test1"] = g1::element::random_element();
23-
key_data.commitments["test2"] = g1::element::random_element();
24-
key_data.commitments["foo1"] = g1::element::random_element();
25-
key_data.commitments["foo2"] = g1::element::random_element();
26-
return key_data;
51+
using RecursVk = typename TestFixture::RecursVk;
52+
auto composer = TestFixture::init_composer();
53+
54+
verification_key_data vk_data = TestFixture::rand_vk_data();
55+
verification_key_data vk_data_copy = vk_data;
56+
57+
auto file_crs = std::make_unique<bonk::FileReferenceStringFactory>("../srs_db/ignition");
58+
auto file_verifier = file_crs->get_verifier_crs();
59+
60+
auto native_vk = std::make_shared<bonk::verification_key>(std::move(vk_data_copy), file_verifier);
61+
auto recurs_vk = RecursVk::from_witness(&composer, native_vk);
62+
63+
EXPECT_EQ(vk_data.compress_native(0), RecursVk::compress_native(native_vk, 0));
64+
EXPECT_EQ(vk_data.compress_native(15), RecursVk::compress_native(native_vk, 15));
65+
// ne hash indeces still lead to ne compressions
66+
EXPECT_NE(vk_data.compress_native(0), RecursVk::compress_native(native_vk, 15));
67+
EXPECT_NE(vk_data.compress_native(14), RecursVk::compress_native(native_vk, 15));
2768
}
2869

29-
TEST(stdlib_verification_key, compress_native_comparison)
70+
TYPED_TEST(VerificationKeyFixture, compress_vs_compress_native)
3071
{
31-
// Compute compression of native verification key (i.e. vk_data)
32-
auto crs = std::make_unique<bonk::FileReferenceStringFactory>("../srs_db/ignition");
33-
verification_key_data vk_data = rand_vk_data(stdlib::types::Composer::type);
34-
const size_t hash_idx = 10;
35-
auto native_vk_compression = vk_data.compress_native(hash_idx);
36-
37-
// Compute compression of recursive verification key
38-
auto verification_key = std::make_shared<bonk::verification_key>(std::move(vk_data), crs->get_verifier_crs());
39-
auto recursive_vk_compression =
40-
stdlib::recursion::verification_key<stdlib::types::bn254>::compress_native(verification_key, hash_idx);
41-
EXPECT_EQ(native_vk_compression, recursive_vk_compression);
42-
}
72+
using RecursVk = typename TestFixture::RecursVk;
73+
auto composer = TestFixture::init_composer();
74+
75+
verification_key_data vk_data = TestFixture::rand_vk_data();
76+
77+
auto file_crs = std::make_unique<bonk::FileReferenceStringFactory>("../srs_db/ignition");
78+
auto file_verifier = file_crs->get_verifier_crs();
79+
80+
auto native_vk = std::make_shared<bonk::verification_key>(std::move(vk_data), file_verifier);
81+
auto recurs_vk = RecursVk::from_witness(&composer, native_vk);
82+
83+
EXPECT_EQ(
84+
recurs_vk->compress(0).get_value(),
85+
RecursVk::compress_native(native_vk, 0)
86+
);
87+
EXPECT_EQ(
88+
recurs_vk->compress(15).get_value(),
89+
RecursVk::compress_native(native_vk, 15)
90+
);
91+
// ne hash indeces still lead to ne compressions
92+
EXPECT_NE(
93+
recurs_vk->compress(0).get_value(),
94+
RecursVk::compress_native(native_vk, 15)
95+
);
96+
EXPECT_NE(
97+
recurs_vk->compress(14).get_value(),
98+
RecursVk::compress_native(native_vk, 15)
99+
);
100+
}

0 commit comments

Comments
 (0)