hyperplonk/subroutines/benches/iop_bench.rs
subroutines/benches/iop_bench.rsRaw
1// Copyright (c) 2023 Espresso Systems (espressosys.com)
2// This file is part of the HyperPlonk library.
3
4// You should have received a copy of the MIT License
5// along with the HyperPlonk library. If not, see <https://mit-license.org/>.
6
7use arithmetic::{identity_permutation_mles, VPAuxInfo, VirtualPolynomial};
8use ark_bls12_381::{Bls12_381, Fr};
9use ark_poly::{DenseMultilinearExtension, MultilinearExtension};
10use ark_std::test_rng;
11use std::{marker::PhantomData, sync::Arc, time::Instant};
12use subroutines::{
13 pcs::{prelude::MultilinearKzgPCS, PolynomialCommitmentScheme},
14 poly_iop::prelude::{
15 PermutationCheck, PolyIOP, PolyIOPErrors, ProductCheck, SumCheck, ZeroCheck,
16 },
17};
18
19type KZG = MultilinearKzgPCS<Bls12_381>;
20
21fn main() -> Result<(), PolyIOPErrors> {
22 bench_permutation_check()?;
23 println!("\n\n");
24 bench_sum_check()?;
25 println!("\n\n");
26 bench_prod_check()?;
27 println!("\n\n");
28 bench_zero_check()
29}
30
31fn bench_sum_check() -> Result<(), PolyIOPErrors> {
32 let mut rng = test_rng();
33 for degree in 2..4 {
34 for nv in 4..25 {
35 let repetition = if nv < 10 {
36 100
37 } else if nv < 20 {
38 50
39 } else {
40 10
41 };
42
43 let (poly, asserted_sum) =
44 VirtualPolynomial::rand(nv, (degree, degree + 1), 2, &mut rng)?;
45 let poly_info = poly.aux_info.clone();
46 let proof = {
47 let start = Instant::now();
48 for _ in 0..repetition {
49 let mut transcript = <PolyIOP<Fr> as SumCheck<Fr>>::init_transcript();
50 let _proof = <PolyIOP<Fr> as SumCheck<Fr>>::prove(&poly, &mut transcript)?;
51 }
52
53 println!(
54 "sum check proving time for {} variables and {} degree: {} ns",
55 nv,
56 degree,
57 start.elapsed().as_nanos() / repetition as u128
58 );
59 let mut transcript = <PolyIOP<Fr> as SumCheck<Fr>>::init_transcript();
60 <PolyIOP<Fr> as SumCheck<Fr>>::prove(&poly, &mut transcript)?
61 };
62
63 {
64 let start = Instant::now();
65
66 for _ in 0..repetition {
67 let mut transcript = <PolyIOP<Fr> as SumCheck<Fr>>::init_transcript();
68 let _subclaim = <PolyIOP<Fr> as SumCheck<Fr>>::verify(
69 asserted_sum,
70 &proof,
71 &poly_info,
72 &mut transcript,
73 )?;
74 }
75 println!(
76 "sum check verification time for {} variables and {} degree: {} ns",
77 nv,
78 degree,
79 start.elapsed().as_nanos() / repetition as u128
80 );
81 }
82
83 println!("====================================");
84 }
85 }
86 Ok(())
87}
88
89fn bench_zero_check() -> Result<(), PolyIOPErrors> {
90 let mut rng = test_rng();
91 for degree in 2..4 {
92 for nv in 4..20 {
93 let repetition = if nv < 10 {
94 100
95 } else if nv < 20 {
96 50
97 } else {
98 10
99 };
100
101 let poly = VirtualPolynomial::rand_zero(nv, (degree, degree + 1), 2, &mut rng)?;
102 let poly_info = poly.aux_info.clone();
103 let proof = {
104 let start = Instant::now();
105 let mut transcript = <PolyIOP<Fr> as ZeroCheck<Fr>>::init_transcript();
106 transcript.append_message(b"testing", b"initializing transcript for testing")?;
107 let proof = <PolyIOP<Fr> as ZeroCheck<Fr>>::prove(&poly, &mut transcript)?;
108
109 println!(
110 "zero check proving time for {} variables and {} degree: {} ns",
111 nv,
112 degree,
113 start.elapsed().as_nanos() / repetition as u128
114 );
115 proof
116 };
117
118 {
119 let start = Instant::now();
120 let mut transcript = <PolyIOP<Fr> as ZeroCheck<Fr>>::init_transcript();
121 transcript.append_message(b"testing", b"initializing transcript for testing")?;
122 let _zero_subclaim =
123 <PolyIOP<Fr> as ZeroCheck<Fr>>::verify(&proof, &poly_info, &mut transcript)?;
124 println!(
125 "zero check verification time for {} variables and {} degree: {} ns",
126 nv,
127 degree,
128 start.elapsed().as_nanos() / repetition as u128
129 );
130 }
131
132 println!("====================================");
133 }
134 }
135 Ok(())
136}
137
138fn bench_permutation_check() -> Result<(), PolyIOPErrors> {
139 let mut rng = test_rng();
140
141 for nv in 4..20 {
142 let srs = KZG::gen_srs_for_testing(&mut rng, nv + 1)?;
143 let (pcs_param, _) = KZG::trim(&srs, None, Some(nv + 1))?;
144
145 let repetition = if nv < 10 {
146 100
147 } else if nv < 20 {
148 50
149 } else {
150 10
151 };
152
153 let ws = vec![Arc::new(DenseMultilinearExtension::rand(nv, &mut rng))];
154
155 // identity map
156 let perms = identity_permutation_mles(nv, 1);
157
158 let proof =
159 {
160 let start = Instant::now();
161 let mut transcript =
162 <PolyIOP<Fr> as PermutationCheck<Bls12_381, KZG>>::init_transcript();
163 transcript.append_message(b"testing", b"initializing transcript for testing")?;
164
165 let (proof, _q_x, _frac_poly) = <PolyIOP<Fr> as PermutationCheck<
166 Bls12_381,
167 KZG,
168 >>::prove(
169 &pcs_param, &ws, &ws, &perms, &mut transcript
170 )?;
171
172 println!(
173 "permutation check proving time for {} variables: {} ns",
174 nv,
175 start.elapsed().as_nanos() / repetition as u128
176 );
177 proof
178 };
179
180 {
181 let poly_info = VPAuxInfo {
182 max_degree: 2,
183 num_variables: nv,
184 phantom: PhantomData::default(),
185 };
186
187 let start = Instant::now();
188 let mut transcript =
189 <PolyIOP<Fr> as PermutationCheck<Bls12_381, KZG>>::init_transcript();
190 transcript.append_message(b"testing", b"initializing transcript for testing")?;
191 let _perm_check_sum_claim = <PolyIOP<Fr> as PermutationCheck<Bls12_381, KZG>>::verify(
192 &proof,
193 &poly_info,
194 &mut transcript,
195 )?;
196 println!(
197 "permutation check verification time for {} variables: {} ns",
198 nv,
199 start.elapsed().as_nanos() / repetition as u128
200 );
201 }
202
203 println!("====================================");
204 }
205
206 Ok(())
207}
208
209fn bench_prod_check() -> Result<(), PolyIOPErrors> {
210 let mut rng = test_rng();
211
212 for nv in 4..20 {
213 let srs = KZG::gen_srs_for_testing(&mut rng, nv + 1)?;
214 let (pcs_param, _) = KZG::trim(&srs, None, Some(nv + 1))?;
215
216 let repetition = if nv < 10 {
217 100
218 } else if nv < 20 {
219 50
220 } else {
221 10
222 };
223
224 let f: DenseMultilinearExtension<Fr> = DenseMultilinearExtension::rand(nv, &mut rng);
225 let mut g = f.clone();
226 g.evaluations.reverse();
227 let fs = vec![Arc::new(f)];
228 let gs = vec![Arc::new(g)];
229
230 let proof = {
231 let start = Instant::now();
232 let mut transcript = <PolyIOP<Fr> as ProductCheck<Bls12_381, KZG>>::init_transcript();
233 transcript.append_message(b"testing", b"initializing transcript for testing")?;
234
235 let (proof, _prod_x, _frac_poly) =
236 <PolyIOP<Fr> as ProductCheck<Bls12_381, KZG>>::prove(
237 &pcs_param,
238 &fs,
239 &gs,
240 &mut transcript,
241 )?;
242
243 println!(
244 "product check proving time for {} variables: {} ns",
245 nv,
246 start.elapsed().as_nanos() / repetition as u128
247 );
248 proof
249 };
250
251 {
252 let poly_info = VPAuxInfo {
253 max_degree: 2,
254 num_variables: nv,
255 phantom: PhantomData::default(),
256 };
257
258 let start = Instant::now();
259 let mut transcript = <PolyIOP<Fr> as ProductCheck<Bls12_381, KZG>>::init_transcript();
260 transcript.append_message(b"testing", b"initializing transcript for testing")?;
261 let _perm_check_sum_claim = <PolyIOP<Fr> as ProductCheck<Bls12_381, KZG>>::verify(
262 &proof,
263 &poly_info,
264 &mut transcript,
265 )?;
266 println!(
267 "product check verification time for {} variables: {} ns",
268 nv,
269 start.elapsed().as_nanos() / repetition as u128
270 );
271 }
272
273 println!("====================================");
274 }
275
276 Ok(())
277}