barretenberg
Loading...
Searching...
No Matches
plookup_tables.hpp
1#pragma once
2#include "barretenberg/common/throw_or_abort.hpp"
3
4#include "./fixed_base/fixed_base.hpp"
5#include "aes128.hpp"
6#include "blake2s.hpp"
7#include "dummy.hpp"
8#include "keccak/keccak_chi.hpp"
9#include "keccak/keccak_input.hpp"
10#include "keccak/keccak_output.hpp"
11#include "keccak/keccak_rho.hpp"
12#include "keccak/keccak_theta.hpp"
13#include "non_native_group_generator.hpp"
14#include "sha256.hpp"
15#include "sparse.hpp"
16#include "types.hpp"
17#include "uint.hpp"
18
19namespace plookup {
20
21const MultiTable& create_table(MultiTableId id);
22
23ReadData<barretenberg::fr> get_lookup_accumulators(MultiTableId id,
24 const barretenberg::fr& key_a,
25 const barretenberg::fr& key_b = 0,
26 bool is_2_to_1_lookup = false);
27
28inline BasicTable create_basic_table(const BasicTableId id, const size_t index)
29{
30 // we have >50 basic fixed base tables so we match with some logic instead of a switch statement
31 auto id_var = static_cast<size_t>(id);
32 if (id_var >= static_cast<size_t>(FIXED_BASE_0_0) && id_var < static_cast<size_t>(FIXED_BASE_1_0)) {
33 return fixed_base::table::generate_basic_fixed_base_table<0>(
34 id, index, id_var - static_cast<size_t>(FIXED_BASE_0_0));
35 }
36 if (id_var >= static_cast<size_t>(FIXED_BASE_1_0) && id_var < static_cast<size_t>(FIXED_BASE_2_0)) {
37 return fixed_base::table::generate_basic_fixed_base_table<1>(
38 id, index, id_var - static_cast<size_t>(FIXED_BASE_1_0));
39 }
40 if (id_var >= static_cast<size_t>(FIXED_BASE_2_0) && id_var < static_cast<size_t>(FIXED_BASE_3_0)) {
41 return fixed_base::table::generate_basic_fixed_base_table<2>(
42 id, index, id_var - static_cast<size_t>(FIXED_BASE_2_0));
43 }
44 if (id_var >= static_cast<size_t>(FIXED_BASE_3_0) && id_var < static_cast<size_t>(HONK_DUMMY_BASIC1)) {
45 return fixed_base::table::generate_basic_fixed_base_table<3>(
46 id, index, id_var - static_cast<size_t>(FIXED_BASE_3_0));
47 }
48 switch (id) {
49 case AES_SPARSE_MAP: {
50 return sparse_tables::generate_sparse_table_with_rotation<9, 8, 0>(AES_SPARSE_MAP, index);
51 }
52 case AES_SBOX_MAP: {
53 return aes128_tables::generate_aes_sbox_table(AES_SBOX_MAP, index);
54 }
55 case AES_SPARSE_NORMALIZE: {
56 return aes128_tables::generate_aes_sparse_normalization_table(AES_SPARSE_NORMALIZE, index);
57 }
58 case SHA256_WITNESS_NORMALIZE: {
59 return sha256_tables::generate_witness_extension_normalization_table(SHA256_WITNESS_NORMALIZE, index);
60 }
61 case SHA256_WITNESS_SLICE_3: {
62 return sparse_tables::generate_sparse_table_with_rotation<16, 3, 0>(SHA256_WITNESS_SLICE_3, index);
63 }
64 case SHA256_WITNESS_SLICE_7_ROTATE_4: {
65 return sparse_tables::generate_sparse_table_with_rotation<16, 7, 4>(SHA256_WITNESS_SLICE_7_ROTATE_4, index);
66 }
67 case SHA256_WITNESS_SLICE_8_ROTATE_7: {
68 return sparse_tables::generate_sparse_table_with_rotation<16, 8, 7>(SHA256_WITNESS_SLICE_8_ROTATE_7, index);
69 }
70 case SHA256_WITNESS_SLICE_14_ROTATE_1: {
71 return sparse_tables::generate_sparse_table_with_rotation<16, 14, 1>(SHA256_WITNESS_SLICE_14_ROTATE_1, index);
72 }
73 case SHA256_CH_NORMALIZE: {
74 return sha256_tables::generate_choose_normalization_table(SHA256_CH_NORMALIZE, index);
75 }
76 case SHA256_MAJ_NORMALIZE: {
77 return sha256_tables::generate_majority_normalization_table(SHA256_MAJ_NORMALIZE, index);
78 }
79 case SHA256_BASE28: {
80 return sparse_tables::generate_sparse_table_with_rotation<28, 11, 0>(SHA256_BASE28, index);
81 }
82 case SHA256_BASE28_ROTATE6: {
83 return sparse_tables::generate_sparse_table_with_rotation<28, 11, 6>(SHA256_BASE28_ROTATE6, index);
84 }
85 case SHA256_BASE28_ROTATE3: {
86 return sparse_tables::generate_sparse_table_with_rotation<28, 11, 3>(SHA256_BASE28_ROTATE3, index);
87 }
88 case SHA256_BASE16: {
89 return sparse_tables::generate_sparse_table_with_rotation<16, 11, 0>(SHA256_BASE16, index);
90 }
91 case SHA256_BASE16_ROTATE2: {
92 return sparse_tables::generate_sparse_table_with_rotation<16, 11, 2>(SHA256_BASE16_ROTATE2, index);
93 }
94 case UINT_XOR_ROTATE0: {
95 return uint_tables::generate_xor_rotate_table<6, 0>(UINT_XOR_ROTATE0, index);
96 }
97 case UINT_AND_ROTATE0: {
98 return uint_tables::generate_and_rotate_table<6, 0>(UINT_AND_ROTATE0, index);
99 }
100 case BN254_XLO_BASIC: {
101 return ecc_generator_tables::ecc_generator_table<barretenberg::g1>::generate_xlo_table(BN254_XLO_BASIC, index);
102 }
103 case BN254_XHI_BASIC: {
104 return ecc_generator_tables::ecc_generator_table<barretenberg::g1>::generate_xhi_table(BN254_XHI_BASIC, index);
105 }
106 case BN254_YLO_BASIC: {
107 return ecc_generator_tables::ecc_generator_table<barretenberg::g1>::generate_ylo_table(BN254_YLO_BASIC, index);
108 }
109 case BN254_YHI_BASIC: {
110 return ecc_generator_tables::ecc_generator_table<barretenberg::g1>::generate_yhi_table(BN254_YHI_BASIC, index);
111 }
112 case BN254_XYPRIME_BASIC: {
113 return ecc_generator_tables::ecc_generator_table<barretenberg::g1>::generate_xyprime_table(BN254_XYPRIME_BASIC,
114 index);
115 }
116 case BN254_XLO_ENDO_BASIC: {
117 return ecc_generator_tables::ecc_generator_table<barretenberg::g1>::generate_xlo_endo_table(
118 BN254_XLO_ENDO_BASIC, index);
119 }
120 case BN254_XHI_ENDO_BASIC: {
121 return ecc_generator_tables::ecc_generator_table<barretenberg::g1>::generate_xhi_endo_table(
122 BN254_XHI_ENDO_BASIC, index);
123 }
124 case BN254_XYPRIME_ENDO_BASIC: {
125 return ecc_generator_tables::ecc_generator_table<barretenberg::g1>::generate_xyprime_endo_table(
126 BN254_XYPRIME_ENDO_BASIC, index);
127 }
128 case SECP256K1_XLO_BASIC: {
129 return ecc_generator_tables::ecc_generator_table<secp256k1::g1>::generate_xlo_table(SECP256K1_XLO_BASIC, index);
130 }
131 case SECP256K1_XHI_BASIC: {
132 return ecc_generator_tables::ecc_generator_table<secp256k1::g1>::generate_xhi_table(SECP256K1_XHI_BASIC, index);
133 }
134 case SECP256K1_YLO_BASIC: {
135 return ecc_generator_tables::ecc_generator_table<secp256k1::g1>::generate_ylo_table(SECP256K1_YLO_BASIC, index);
136 }
137 case SECP256K1_YHI_BASIC: {
138 return ecc_generator_tables::ecc_generator_table<secp256k1::g1>::generate_yhi_table(SECP256K1_YHI_BASIC, index);
139 }
140 case SECP256K1_XYPRIME_BASIC: {
141 return ecc_generator_tables::ecc_generator_table<secp256k1::g1>::generate_xyprime_table(SECP256K1_XYPRIME_BASIC,
142 index);
143 }
144 case SECP256K1_XLO_ENDO_BASIC: {
145 return ecc_generator_tables::ecc_generator_table<secp256k1::g1>::generate_xlo_endo_table(
146 SECP256K1_XLO_ENDO_BASIC, index);
147 }
148 case SECP256K1_XHI_ENDO_BASIC: {
149 return ecc_generator_tables::ecc_generator_table<secp256k1::g1>::generate_xhi_endo_table(
150 SECP256K1_XHI_ENDO_BASIC, index);
151 }
152 case SECP256K1_XYPRIME_ENDO_BASIC: {
153 return ecc_generator_tables::ecc_generator_table<secp256k1::g1>::generate_xyprime_endo_table(
154 SECP256K1_XYPRIME_ENDO_BASIC, index);
155 }
156 case BLAKE_XOR_ROTATE0: {
157 return blake2s_tables::generate_xor_rotate_table<6, 0>(BLAKE_XOR_ROTATE0, index);
158 }
159 case BLAKE_XOR_ROTATE0_SLICE5_MOD4: {
160 return blake2s_tables::generate_xor_rotate_table<5, 0, true>(BLAKE_XOR_ROTATE0_SLICE5_MOD4, index);
161 }
162 case BLAKE_XOR_ROTATE2: {
163 return blake2s_tables::generate_xor_rotate_table<6, 2>(BLAKE_XOR_ROTATE2, index);
164 }
165 case BLAKE_XOR_ROTATE1: {
166 return blake2s_tables::generate_xor_rotate_table<6, 1>(BLAKE_XOR_ROTATE1, index);
167 }
168 case BLAKE_XOR_ROTATE4: {
169 return blake2s_tables::generate_xor_rotate_table<6, 4>(BLAKE_XOR_ROTATE4, index);
170 }
171 case HONK_DUMMY_BASIC1: {
172 return dummy_tables::generate_honk_dummy_table<HONK_DUMMY_BASIC1>(HONK_DUMMY_BASIC1, index);
173 }
174 case HONK_DUMMY_BASIC2: {
175 return dummy_tables::generate_honk_dummy_table<HONK_DUMMY_BASIC2>(HONK_DUMMY_BASIC2, index);
176 }
177 case KECCAK_INPUT: {
178 return keccak_tables::KeccakInput::generate_keccak_input_table(KECCAK_INPUT, index);
179 }
180 case KECCAK_THETA: {
181 return keccak_tables::Theta::generate_theta_renormalization_table(KECCAK_THETA, index);
182 }
183 case KECCAK_CHI: {
184 return keccak_tables::Chi::generate_chi_renormalization_table(KECCAK_CHI, index);
185 }
186 case KECCAK_OUTPUT: {
187 return keccak_tables::KeccakOutput::generate_keccak_output_table(KECCAK_OUTPUT, index);
188 }
189 case KECCAK_RHO_1: {
190 return keccak_tables::Rho<1>::generate_rho_renormalization_table(KECCAK_RHO_1, index);
191 }
192 case KECCAK_RHO_2: {
193 return keccak_tables::Rho<2>::generate_rho_renormalization_table(KECCAK_RHO_2, index);
194 }
195 case KECCAK_RHO_3: {
196 return keccak_tables::Rho<3>::generate_rho_renormalization_table(KECCAK_RHO_3, index);
197 }
198 case KECCAK_RHO_4: {
199 return keccak_tables::Rho<4>::generate_rho_renormalization_table(KECCAK_RHO_4, index);
200 }
201 case KECCAK_RHO_5: {
202 return keccak_tables::Rho<5>::generate_rho_renormalization_table(KECCAK_RHO_5, index);
203 }
204 case KECCAK_RHO_6: {
205 return keccak_tables::Rho<6>::generate_rho_renormalization_table(KECCAK_RHO_6, index);
206 }
207 case KECCAK_RHO_7: {
208 return keccak_tables::Rho<7>::generate_rho_renormalization_table(KECCAK_RHO_7, index);
209 }
210 case KECCAK_RHO_8: {
211 return keccak_tables::Rho<8>::generate_rho_renormalization_table(KECCAK_RHO_8, index);
212 }
213 default: {
214 throw_or_abort("table id does not exist");
215 return sparse_tables::generate_sparse_table_with_rotation<9, 8, 0>(AES_SPARSE_MAP, index);
216 }
217 }
218}
219} // namespace plookup
plookup::keccak_tables::Chi::generate_chi_renormalization_table
static BasicTable generate_chi_renormalization_table(BasicTableId id, const size_t table_index)
Generate the CHI plookup table.
Definition: keccak_chi.hpp:167
plookup::keccak_tables::KeccakInput::generate_keccak_input_table
static BasicTable generate_keccak_input_table(BasicTableId id, const size_t table_index)
Generate plookup table that maps a TABLE_BITS-slice of a base-2 integer into a base-11 representation...
Definition: keccak_input.hpp:56
plookup::keccak_tables::KeccakOutput::generate_keccak_output_table
static BasicTable generate_keccak_output_table(BasicTableId id, const size_t table_index)
Generate plookup table that maps a TABLE_BITS-slice of a base-11 integer into a base-2 integer.
Definition: keccak_output.hpp:89
plookup::keccak_tables::Rho::generate_rho_renormalization_table
static BasicTable generate_rho_renormalization_table(BasicTableId id, const size_t table_index)
Generate plookup table that normalizes a TABLE_BITS-slice of a base-11 integer and extracts the msb.
Definition: keccak_rho.hpp:168
plookup::keccak_tables::Theta::generate_theta_renormalization_table
static BasicTable generate_theta_renormalization_table(BasicTableId id, const size_t table_index)
Generate plookup table that normalizes a TABLE_BITS-slice of a base-11 integer.
Definition: keccak_theta.hpp:166
dummy.hpp
This file contains functions for the dummy tables that we use in UltraHonk to make table,...
Generated by doxygen 1.9.6