1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
use crate::ahp::{
indexer::{Circuit, CircuitInfo, IndexerConstraintSystem},
matrices::arithmetize_matrix,
AHPError,
AHPForR1CS,
};
use snarkvm_algorithms::fft::EvaluationDomain;
use snarkvm_fields::PrimeField;
use snarkvm_r1cs::errors::SynthesisError;
use snarkvm_r1cs::{ConstraintSynthesizer, ConstraintSystem};
use core::marker::PhantomData;
impl<F: PrimeField> AHPForR1CS<F> {
pub fn index<C: ConstraintSynthesizer<F>>(c: &C) -> Result<Circuit<F>, AHPError> {
let index_time = start_timer!(|| "AHP::Index");
let constraint_time = start_timer!(|| "Generating constraints");
let mut ics = IndexerConstraintSystem::new();
c.generate_constraints(&mut ics)?;
end_timer!(constraint_time);
let padding_time = start_timer!(|| "Padding matrices to make them square");
crate::ahp::matrices::pad_input_for_indexer_and_prover(&mut ics);
ics.make_matrices_square();
let mut a = ics.a_matrix();
let mut b = ics.b_matrix();
let mut c = ics.c_matrix();
crate::ahp::matrices::balance_matrices(&mut a, &mut b);
end_timer!(padding_time);
let num_padded_public_variables = ics.num_public_variables();
let num_private_variables = ics.num_private_variables();
let num_constraints = ics.num_constraints();
let num_non_zero = ics.num_non_zero();
let num_variables = num_padded_public_variables + num_private_variables;
if cfg!(debug_assertions) {
println!("Number of padded public variables: {}", num_padded_public_variables);
println!("Number of private variables: {}", num_private_variables);
println!("Number of num_constraints: {}", num_constraints);
println!("Number of num_non_zero: {}", num_non_zero);
}
if num_constraints != num_variables {
eprintln!("Number of padded public variables: {}", num_padded_public_variables);
eprintln!("Number of private variables: {}", num_private_variables);
eprintln!("Number of num_constraints: {}", num_constraints);
eprintln!("Number of num_non_zero: {}", num_non_zero);
return Err(AHPError::NonSquareMatrix);
}
if !Self::num_formatted_public_inputs_is_admissible(num_padded_public_variables) {
return Err(AHPError::InvalidPublicInputLength);
}
let index_info = CircuitInfo {
num_variables,
num_constraints,
num_non_zero,
f: PhantomData,
};
let domain_h = EvaluationDomain::new(num_constraints).ok_or(SynthesisError::PolynomialDegreeTooLarge)?;
let domain_k = EvaluationDomain::new(num_non_zero).ok_or(SynthesisError::PolynomialDegreeTooLarge)?;
let x_domain =
EvaluationDomain::new(num_padded_public_variables).ok_or(SynthesisError::PolynomialDegreeTooLarge)?;
let b_domain =
EvaluationDomain::new(3 * domain_k.size() - 3).ok_or(SynthesisError::PolynomialDegreeTooLarge)?;
let a_arithmetization_time = start_timer!(|| "Arithmetizing A");
let a_star_arith = arithmetize_matrix("a", &mut a, domain_k, domain_h, x_domain, b_domain);
end_timer!(a_arithmetization_time);
let b_arithmetization_time = start_timer!(|| "Arithmetizing B");
let b_star_arith = arithmetize_matrix("b", &mut b, domain_k, domain_h, x_domain, b_domain);
end_timer!(b_arithmetization_time);
let c_arithmetization_time = start_timer!(|| "Arithmetizing C");
let c_star_arith = arithmetize_matrix("c", &mut c, domain_k, domain_h, x_domain, b_domain);
end_timer!(c_arithmetization_time);
end_timer!(index_time);
Ok(Circuit {
index_info,
a,
b,
c,
a_star_arith,
b_star_arith,
c_star_arith,
})
}
}