#![allow(clippy::too_many_arguments)]
|
|
#![allow(clippy::type_complexity)]
|
|
use crate::poseidon_transcript::{AppendToPoseidon, PoseidonTranscript};
|
|
|
|
use super::dense_mlpoly::DensePolynomial;
|
|
use super::errors::ProofVerifyError;
|
|
|
|
use super::scalar::Scalar;
|
|
use super::transcript::ProofTranscript;
|
|
use super::unipoly::UniPoly;
|
|
|
|
use ark_ff::Zero;
|
|
use ark_serialize::*;
|
|
|
|
use itertools::izip;
|
|
|
|
#[derive(CanonicalSerialize, CanonicalDeserialize, Debug)]
|
|
pub struct SumcheckInstanceProof {
|
|
pub polys: Vec<UniPoly>,
|
|
}
|
|
|
|
impl SumcheckInstanceProof {
|
|
pub fn new(polys: Vec<UniPoly>) -> SumcheckInstanceProof {
|
|
SumcheckInstanceProof { polys }
|
|
}
|
|
|
|
pub fn verify(
|
|
&self,
|
|
claim: Scalar,
|
|
num_rounds: usize,
|
|
degree_bound: usize,
|
|
transcript: &mut PoseidonTranscript,
|
|
) -> Result<(Scalar, Vec<Scalar>), ProofVerifyError> {
|
|
let mut e = claim;
|
|
let mut r: Vec<Scalar> = Vec::new();
|
|
|
|
// verify that there is a univariate polynomial for each round
|
|
assert_eq!(self.polys.len(), num_rounds);
|
|
for i in 0..self.polys.len() {
|
|
let poly = self.polys[i].clone();
|
|
|
|
// verify degree bound
|
|
assert_eq!(poly.degree(), degree_bound);
|
|
// check if G_k(0) + G_k(1) = e
|
|
|
|
assert_eq!(poly.eval_at_zero() + poly.eval_at_one(), e);
|
|
|
|
// append the prover's message to the transcript
|
|
poly.append_to_poseidon(transcript);
|
|
|
|
//derive the verifier's challenge for the next round
|
|
let r_i = transcript.challenge_scalar();
|
|
|
|
r.push(r_i);
|
|
|
|
// evaluate the claimed degree-ell polynomial at r_i
|
|
e = poly.evaluate(&r_i);
|
|
}
|
|
|
|
Ok((e, r))
|
|
}
|
|
}
|
|
|
|
// #[derive(CanonicalSerialize, CanonicalDeserialize, Debug)]
|
|
// pub struct ZKSumcheckInstanceProof {
|
|
// comm_polys: Vec<CompressedGroup>,
|
|
// comm_evals: Vec<CompressedGroup>,
|
|
// proofs: Vec<DotProductProof>,
|
|
// }
|
|
|
|
// impl ZKSumcheckInstanceProof {
|
|
// pub fn new(
|
|
// comm_polys: Vec<CompressedGroup>,
|
|
// comm_evals: Vec<CompressedGroup>,
|
|
// proofs: Vec<DotProductProof>,
|
|
// ) -> Self {
|
|
// ZKSumcheckInstanceProof {
|
|
// comm_polys,
|
|
// comm_evals,
|
|
// proofs,
|
|
// }
|
|
// }
|
|
|
|
// pub fn verify(
|
|
// &self,
|
|
// comm_claim: &CompressedGroup,
|
|
// num_rounds: usize,
|
|
// degree_bound: usize,
|
|
// gens_1: &MultiCommitGens,
|
|
// gens_n: &MultiCommitGens,
|
|
// transcript: &mut Transcript,
|
|
// ) -> Result<(CompressedGroup, Vec<Scalar>), ProofVerifyError> {
|
|
// // verify degree bound
|
|
// assert_eq!(gens_n.n, degree_bound + 1);
|
|
|
|
// // verify that there is a univariate polynomial for each round
|
|
// assert_eq!(self.comm_polys.len(), num_rounds);
|
|
// assert_eq!(self.comm_evals.len(), num_rounds);
|
|
|
|
// let mut r: Vec<Scalar> = Vec::new();
|
|
// for i in 0..self.comm_polys.len() {
|
|
// let comm_poly = &self.comm_polys[i];
|
|
|
|
// // append the prover's polynomial to the transcript
|
|
// comm_poly.append_to_transcript(b"comm_poly", transcript);
|
|
|
|
// //derive the verifier's challenge for the next round
|
|
// let r_i = transcript.challenge_scalar(b"challenge_nextround");
|
|
|
|
// // verify the proof of sum-check and evals
|
|
// let res = {
|
|
// let comm_claim_per_round = if i == 0 {
|
|
// comm_claim
|
|
// } else {
|
|
// &self.comm_evals[i - 1]
|
|
// };
|
|
// let mut comm_eval = &self.comm_evals[i];
|
|
|
|
// // add two claims to transcript
|
|
// comm_claim_per_round.append_to_transcript(transcript);
|
|
// comm_eval.append_to_transcript(transcript);
|
|
|
|
// // produce two weights
|
|
// let w = transcript.challenge_vector(2);
|
|
|
|
// // compute a weighted sum of the RHS
|
|
// let comm_target = GroupElement::vartime_multiscalar_mul(
|
|
// w.as_slice(),
|
|
// iter::once(&comm_claim_per_round)
|
|
// .chain(iter::once(&comm_eval))
|
|
// .map(|pt| GroupElement::decompress(pt).unwrap())
|
|
// .collect::<Vec<GroupElement>>()
|
|
// .as_slice(),
|
|
// )
|
|
// .compress();
|
|
|
|
// let a = {
|
|
// // the vector to use to decommit for sum-check test
|
|
// let a_sc = {
|
|
// let mut a = vec![Scalar::one(); degree_bound + 1];
|
|
// a[0] += Scalar::one();
|
|
// a
|
|
// };
|
|
|
|
// // the vector to use to decommit for evaluation
|
|
// let a_eval = {
|
|
// let mut a = vec![Scalar::one(); degree_bound + 1];
|
|
// for j in 1..a.len() {
|
|
// a[j] = a[j - 1] * r_i;
|
|
// }
|
|
// a
|
|
// };
|
|
|
|
// // take weighted sum of the two vectors using w
|
|
// assert_eq!(a_sc.len(), a_eval.len());
|
|
// (0..a_sc.len())
|
|
// .map(|i| w[0] * a_sc[i] + w[1] * a_eval[i])
|
|
// .collect::<Vec<Scalar>>()
|
|
// };
|
|
|
|
// self.proofs[i]
|
|
// .verify(
|
|
// gens_1,
|
|
// gens_n,
|
|
// transcript,
|
|
// &a,
|
|
// &self.comm_polys[i],
|
|
// &comm_target,
|
|
// )
|
|
// .is_ok()
|
|
// };
|
|
// if !res {
|
|
// return Err(ProofVerifyError::InternalError);
|
|
// }
|
|
|
|
// r.push(r_i);
|
|
// }
|
|
|
|
// Ok((self.comm_evals[&self.comm_evals.len() - 1].clone(), r))
|
|
// }
|
|
// }
|
|
|
|
impl SumcheckInstanceProof {
|
|
pub fn prove_cubic_with_additive_term<F>(
|
|
claim: &Scalar,
|
|
num_rounds: usize,
|
|
poly_tau: &mut DensePolynomial,
|
|
poly_A: &mut DensePolynomial,
|
|
poly_B: &mut DensePolynomial,
|
|
poly_C: &mut DensePolynomial,
|
|
comb_func: F,
|
|
transcript: &mut PoseidonTranscript,
|
|
) -> (Self, Vec<Scalar>, Vec<Scalar>)
|
|
where
|
|
F: Fn(&Scalar, &Scalar, &Scalar, &Scalar) -> Scalar,
|
|
{
|
|
let mut e = *claim;
|
|
let mut r: Vec<Scalar> = Vec::new();
|
|
let mut cubic_polys: Vec<UniPoly> = Vec::new();
|
|
for _j in 0..num_rounds {
|
|
let mut eval_point_0 = Scalar::zero();
|
|
let mut eval_point_2 = Scalar::zero();
|
|
let mut eval_point_3 = Scalar::zero();
|
|
|
|
let len = poly_tau.len() / 2;
|
|
for i in 0..len {
|
|
// eval 0: bound_func is A(low)
|
|
eval_point_0 += comb_func(&poly_tau[i], &poly_A[i], &poly_B[i], &poly_C[i]);
|
|
|
|
// eval 2: bound_func is -A(low) + 2*A(high)
|
|
let poly_tau_bound_point = poly_tau[len + i] + poly_tau[len + i] - poly_tau[i];
|
|
let poly_A_bound_point = poly_A[len + i] + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B[len + i] + poly_B[len + i] - poly_B[i];
|
|
let poly_C_bound_point = poly_C[len + i] + poly_C[len + i] - poly_C[i];
|
|
|
|
eval_point_2 += comb_func(
|
|
&poly_tau_bound_point,
|
|
&poly_A_bound_point,
|
|
&poly_B_bound_point,
|
|
&poly_C_bound_point,
|
|
);
|
|
|
|
// eval 3: bound_func is -2A(low) + 3A(high); computed incrementally with bound_func applied to eval(2)
|
|
let poly_tau_bound_point = poly_tau_bound_point + poly_tau[len + i] - poly_tau[i];
|
|
let poly_A_bound_point = poly_A_bound_point + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B_bound_point + poly_B[len + i] - poly_B[i];
|
|
let poly_C_bound_point = poly_C_bound_point + poly_C[len + i] - poly_C[i];
|
|
|
|
eval_point_3 += comb_func(
|
|
&poly_tau_bound_point,
|
|
&poly_A_bound_point,
|
|
&poly_B_bound_point,
|
|
&poly_C_bound_point,
|
|
);
|
|
}
|
|
|
|
let evals = vec![eval_point_0, e - eval_point_0, eval_point_2, eval_point_3];
|
|
let poly = UniPoly::from_evals(&evals);
|
|
|
|
// append the prover's message to the transcript
|
|
poly.append_to_poseidon(transcript);
|
|
//derive the verifier's challenge for the next round
|
|
let r_j = transcript.challenge_scalar();
|
|
r.push(r_j);
|
|
|
|
// bound all tables to the verifier's challenege
|
|
poly_tau.bound_poly_var_top(&r_j);
|
|
poly_A.bound_poly_var_top(&r_j);
|
|
poly_B.bound_poly_var_top(&r_j);
|
|
poly_C.bound_poly_var_top(&r_j);
|
|
|
|
e = poly.evaluate(&r_j);
|
|
cubic_polys.push(poly);
|
|
}
|
|
(
|
|
SumcheckInstanceProof::new(cubic_polys),
|
|
r,
|
|
vec![poly_tau[0], poly_A[0], poly_B[0], poly_C[0]],
|
|
)
|
|
}
|
|
pub fn prove_cubic<F>(
|
|
claim: &Scalar,
|
|
num_rounds: usize,
|
|
poly_A: &mut DensePolynomial,
|
|
poly_B: &mut DensePolynomial,
|
|
poly_C: &mut DensePolynomial,
|
|
comb_func: F,
|
|
transcript: &mut PoseidonTranscript,
|
|
) -> (Self, Vec<Scalar>, Vec<Scalar>)
|
|
where
|
|
F: Fn(&Scalar, &Scalar, &Scalar) -> Scalar,
|
|
{
|
|
let mut e = *claim;
|
|
let mut r: Vec<Scalar> = Vec::new();
|
|
let mut cubic_polys: Vec<UniPoly> = Vec::new();
|
|
for _j in 0..num_rounds {
|
|
let mut eval_point_0 = Scalar::zero();
|
|
let mut eval_point_2 = Scalar::zero();
|
|
let mut eval_point_3 = Scalar::zero();
|
|
|
|
let len = poly_A.len() / 2;
|
|
for i in 0..len {
|
|
// eval 0: bound_func is A(low)
|
|
eval_point_0 += comb_func(&poly_A[i], &poly_B[i], &poly_C[i]);
|
|
|
|
// eval 2: bound_func is -A(low) + 2*A(high)
|
|
let poly_A_bound_point = poly_A[len + i] + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B[len + i] + poly_B[len + i] - poly_B[i];
|
|
let poly_C_bound_point = poly_C[len + i] + poly_C[len + i] - poly_C[i];
|
|
eval_point_2 += comb_func(
|
|
&poly_A_bound_point,
|
|
&poly_B_bound_point,
|
|
&poly_C_bound_point,
|
|
);
|
|
|
|
// eval 3: bound_func is -2A(low) + 3A(high); computed incrementally with bound_func applied to eval(2)
|
|
let poly_A_bound_point = poly_A_bound_point + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B_bound_point + poly_B[len + i] - poly_B[i];
|
|
let poly_C_bound_point = poly_C_bound_point + poly_C[len + i] - poly_C[i];
|
|
|
|
eval_point_3 += comb_func(
|
|
&poly_A_bound_point,
|
|
&poly_B_bound_point,
|
|
&poly_C_bound_point,
|
|
);
|
|
}
|
|
|
|
let evals = vec![eval_point_0, e - eval_point_0, eval_point_2, eval_point_3];
|
|
let poly = UniPoly::from_evals(&evals);
|
|
|
|
// append the prover's message to the transcript
|
|
poly.append_to_poseidon(transcript);
|
|
|
|
//derive the verifier's challenge for the next round
|
|
let r_j = transcript.challenge_scalar();
|
|
r.push(r_j);
|
|
// bound all tables to the verifier's challenege
|
|
poly_A.bound_poly_var_top(&r_j);
|
|
poly_B.bound_poly_var_top(&r_j);
|
|
poly_C.bound_poly_var_top(&r_j);
|
|
e = poly.evaluate(&r_j);
|
|
cubic_polys.push(poly);
|
|
}
|
|
|
|
(
|
|
SumcheckInstanceProof::new(cubic_polys),
|
|
r,
|
|
vec![poly_A[0], poly_B[0], poly_C[0]],
|
|
)
|
|
}
|
|
|
|
pub fn prove_cubic_batched<F>(
|
|
claim: &Scalar,
|
|
num_rounds: usize,
|
|
poly_vec_par: (
|
|
&mut Vec<&mut DensePolynomial>,
|
|
&mut Vec<&mut DensePolynomial>,
|
|
&mut DensePolynomial,
|
|
),
|
|
poly_vec_seq: (
|
|
&mut Vec<&mut DensePolynomial>,
|
|
&mut Vec<&mut DensePolynomial>,
|
|
&mut Vec<&mut DensePolynomial>,
|
|
),
|
|
coeffs: &[Scalar],
|
|
comb_func: F,
|
|
transcript: &mut PoseidonTranscript,
|
|
) -> (
|
|
Self,
|
|
Vec<Scalar>,
|
|
(Vec<Scalar>, Vec<Scalar>, Scalar),
|
|
(Vec<Scalar>, Vec<Scalar>, Vec<Scalar>),
|
|
)
|
|
where
|
|
F: Fn(&Scalar, &Scalar, &Scalar) -> Scalar,
|
|
{
|
|
let (poly_A_vec_par, poly_B_vec_par, poly_C_par) = poly_vec_par;
|
|
let (poly_A_vec_seq, poly_B_vec_seq, poly_C_vec_seq) = poly_vec_seq;
|
|
|
|
//let (poly_A_vec_seq, poly_B_vec_seq, poly_C_vec_seq) = poly_vec_seq;
|
|
let mut e = *claim;
|
|
let mut r: Vec<Scalar> = Vec::new();
|
|
let mut cubic_polys: Vec<UniPoly> = Vec::new();
|
|
|
|
for _j in 0..num_rounds {
|
|
let mut evals: Vec<(Scalar, Scalar, Scalar)> = Vec::new();
|
|
|
|
for (poly_A, poly_B) in poly_A_vec_par.iter().zip(poly_B_vec_par.iter()) {
|
|
let mut eval_point_0 = Scalar::zero();
|
|
let mut eval_point_2 = Scalar::zero();
|
|
let mut eval_point_3 = Scalar::zero();
|
|
|
|
let len = poly_A.len() / 2;
|
|
for i in 0..len {
|
|
// eval 0: bound_func is A(low)
|
|
eval_point_0 += comb_func(&poly_A[i], &poly_B[i], &poly_C_par[i]);
|
|
|
|
// eval 2: bound_func is -A(low) + 2*A(high)
|
|
let poly_A_bound_point = poly_A[len + i] + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B[len + i] + poly_B[len + i] - poly_B[i];
|
|
let poly_C_bound_point = poly_C_par[len + i] + poly_C_par[len + i] - poly_C_par[i];
|
|
eval_point_2 += comb_func(
|
|
&poly_A_bound_point,
|
|
&poly_B_bound_point,
|
|
&poly_C_bound_point,
|
|
);
|
|
|
|
// eval 3: bound_func is -2A(low) + 3A(high); computed incrementally with bound_func applied to eval(2)
|
|
let poly_A_bound_point = poly_A_bound_point + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B_bound_point + poly_B[len + i] - poly_B[i];
|
|
let poly_C_bound_point = poly_C_bound_point + poly_C_par[len + i] - poly_C_par[i];
|
|
|
|
eval_point_3 += comb_func(
|
|
&poly_A_bound_point,
|
|
&poly_B_bound_point,
|
|
&poly_C_bound_point,
|
|
);
|
|
}
|
|
|
|
evals.push((eval_point_0, eval_point_2, eval_point_3));
|
|
}
|
|
|
|
for (poly_A, poly_B, poly_C) in izip!(
|
|
poly_A_vec_seq.iter(),
|
|
poly_B_vec_seq.iter(),
|
|
poly_C_vec_seq.iter()
|
|
) {
|
|
let mut eval_point_0 = Scalar::zero();
|
|
let mut eval_point_2 = Scalar::zero();
|
|
let mut eval_point_3 = Scalar::zero();
|
|
let len = poly_A.len() / 2;
|
|
for i in 0..len {
|
|
// eval 0: bound_func is A(low)
|
|
eval_point_0 += comb_func(&poly_A[i], &poly_B[i], &poly_C[i]);
|
|
// eval 2: bound_func is -A(low) + 2*A(high)
|
|
let poly_A_bound_point = poly_A[len + i] + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B[len + i] + poly_B[len + i] - poly_B[i];
|
|
let poly_C_bound_point = poly_C[len + i] + poly_C[len + i] - poly_C[i];
|
|
eval_point_2 += comb_func(
|
|
&poly_A_bound_point,
|
|
&poly_B_bound_point,
|
|
&poly_C_bound_point,
|
|
);
|
|
// eval 3: bound_func is -2A(low) + 3A(high); computed incrementally with bound_func applied to eval(2)
|
|
let poly_A_bound_point = poly_A_bound_point + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B_bound_point + poly_B[len + i] - poly_B[i];
|
|
let poly_C_bound_point = poly_C_bound_point + poly_C[len + i] - poly_C[i];
|
|
eval_point_3 += comb_func(
|
|
&poly_A_bound_point,
|
|
&poly_B_bound_point,
|
|
&poly_C_bound_point,
|
|
);
|
|
}
|
|
evals.push((eval_point_0, eval_point_2, eval_point_3));
|
|
}
|
|
|
|
let evals_combined_0 = (0..evals.len()).map(|i| evals[i].0 * coeffs[i]).sum();
|
|
let evals_combined_2 = (0..evals.len()).map(|i| evals[i].1 * coeffs[i]).sum();
|
|
let evals_combined_3 = (0..evals.len()).map(|i| evals[i].2 * coeffs[i]).sum();
|
|
|
|
let evals = vec![
|
|
evals_combined_0,
|
|
e - evals_combined_0,
|
|
evals_combined_2,
|
|
evals_combined_3,
|
|
];
|
|
let poly = UniPoly::from_evals(&evals);
|
|
|
|
// append the prover's message to the transcript
|
|
poly.append_to_poseidon(transcript);
|
|
|
|
//derive the verifier's challenge for the next round
|
|
let r_j = transcript.challenge_scalar();
|
|
r.push(r_j);
|
|
|
|
// bound all tables to the verifier's challenege
|
|
for (poly_A, poly_B) in poly_A_vec_par.iter_mut().zip(poly_B_vec_par.iter_mut()) {
|
|
poly_A.bound_poly_var_top(&r_j);
|
|
poly_B.bound_poly_var_top(&r_j);
|
|
}
|
|
poly_C_par.bound_poly_var_top(&r_j);
|
|
|
|
for (poly_A, poly_B, poly_C) in izip!(
|
|
poly_A_vec_seq.iter_mut(),
|
|
poly_B_vec_seq.iter_mut(),
|
|
poly_C_vec_seq.iter_mut()
|
|
) {
|
|
poly_A.bound_poly_var_top(&r_j);
|
|
poly_B.bound_poly_var_top(&r_j);
|
|
poly_C.bound_poly_var_top(&r_j);
|
|
}
|
|
|
|
e = poly.evaluate(&r_j);
|
|
cubic_polys.push(poly);
|
|
}
|
|
|
|
let poly_A_par_final = (0..poly_A_vec_par.len())
|
|
.map(|i| poly_A_vec_par[i][0])
|
|
.collect();
|
|
let poly_B_par_final = (0..poly_B_vec_par.len())
|
|
.map(|i| poly_B_vec_par[i][0])
|
|
.collect();
|
|
let claims_prod = (poly_A_par_final, poly_B_par_final, poly_C_par[0]);
|
|
|
|
let poly_A_seq_final = (0..poly_A_vec_seq.len())
|
|
.map(|i| poly_A_vec_seq[i][0])
|
|
.collect();
|
|
let poly_B_seq_final = (0..poly_B_vec_seq.len())
|
|
.map(|i| poly_B_vec_seq[i][0])
|
|
.collect();
|
|
let poly_C_seq_final = (0..poly_C_vec_seq.len())
|
|
.map(|i| poly_C_vec_seq[i][0])
|
|
.collect();
|
|
let claims_dotp = (poly_A_seq_final, poly_B_seq_final, poly_C_seq_final);
|
|
|
|
(
|
|
SumcheckInstanceProof::new(cubic_polys),
|
|
r,
|
|
claims_prod,
|
|
claims_dotp,
|
|
)
|
|
}
|
|
|
|
pub fn prove_quad<F>(
|
|
claim: &Scalar,
|
|
num_rounds: usize,
|
|
poly_A: &mut DensePolynomial,
|
|
poly_B: &mut DensePolynomial,
|
|
comb_func: F,
|
|
transcript: &mut PoseidonTranscript,
|
|
) -> (Self, Vec<Scalar>, Vec<Scalar>)
|
|
where
|
|
F: Fn(&Scalar, &Scalar) -> Scalar,
|
|
{
|
|
let mut e = *claim;
|
|
let mut r: Vec<Scalar> = Vec::new();
|
|
let mut quad_polys: Vec<UniPoly> = Vec::new();
|
|
|
|
for _j in 0..num_rounds {
|
|
let mut eval_point_0 = Scalar::zero();
|
|
let mut eval_point_2 = Scalar::zero();
|
|
|
|
let len = poly_A.len() / 2;
|
|
for i in 0..len {
|
|
// eval 0: bound_func is A(low)
|
|
eval_point_0 += comb_func(&poly_A[i], &poly_B[i]);
|
|
|
|
// eval 2: bound_func is -A(low) + 2*A(high)
|
|
let poly_A_bound_point = poly_A[len + i] + poly_A[len + i] - poly_A[i];
|
|
let poly_B_bound_point = poly_B[len + i] + poly_B[len + i] - poly_B[i];
|
|
eval_point_2 += comb_func(&poly_A_bound_point, &poly_B_bound_point);
|
|
}
|
|
|
|
let evals = vec![eval_point_0, e - eval_point_0, eval_point_2];
|
|
let poly = UniPoly::from_evals(&evals);
|
|
|
|
// append the prover's message to the transcript
|
|
poly.append_to_poseidon(transcript);
|
|
|
|
//derive the verifier's challenge for the next round
|
|
let r_j = transcript.challenge_scalar();
|
|
r.push(r_j);
|
|
|
|
// bound all tables to the verifier's challenege
|
|
poly_A.bound_poly_var_top(&r_j);
|
|
poly_B.bound_poly_var_top(&r_j);
|
|
e = poly.evaluate(&r_j);
|
|
quad_polys.push(poly);
|
|
}
|
|
|
|
(
|
|
SumcheckInstanceProof::new(quad_polys),
|
|
r,
|
|
vec![poly_A[0], poly_B[0]],
|
|
)
|
|
}
|
|
}
|
|
|
|
// impl ZKSumcheckInstanceProof {
|
|
// pub fn prove_quad<F>(
|
|
// claim: &Scalar,
|
|
// blind_claim: &Scalar,
|
|
// num_rounds: usize,
|
|
// poly_A: &mut DensePolynomial,
|
|
// poly_B: &mut DensePolynomial,
|
|
// comb_func: F,
|
|
// gens_1: &MultiCommitGens,
|
|
// gens_n: &MultiCommitGens,
|
|
// transcript: &mut Transcript,
|
|
// random_tape: &mut RandomTape,
|
|
// ) -> (Self, Vec<Scalar>, Vec<Scalar>, Scalar)
|
|
// where
|
|
// F: Fn(&Scalar, &Scalar) -> Scalar,
|
|
// {
|
|
// let (blinds_poly, blinds_evals) = (
|
|
// random_tape.random_vector(b"blinds_poly", num_rounds),
|
|
// random_tape.random_vector(b"blinds_evals", num_rounds),
|
|
// );
|
|
// let mut claim_per_round = *claim;
|
|
// let mut comm_claim_per_round = claim_per_round.commit(blind_claim, gens_1).compress();
|
|
|
|
// let mut r: Vec<Scalar> = Vec::new();
|
|
// let mut comm_polys: Vec<Group> = Vec::new();
|
|
// let mut comm_evals: Vec<CompressedGroup> = Vec::new();
|
|
// let mut proofs: Vec<DotProductProof> = Vec::new();
|
|
|
|
// for j in 0..num_rounds {
|
|
// let (poly, comm_poly) = {
|
|
// let mut eval_point_0 = Scalar::zero();
|
|
// let mut eval_point_2 = Scalar::zero();
|
|
|
|
// let len = poly_A.len() / 2;
|
|
// for i in 0..len {
|
|
// // eval 0: bound_func is A(low)
|
|
// eval_point_0 += comb_func(&poly_A[i], &poly_B[i]);
|
|
|
|
// // eval 2: bound_func is -A(low) + 2*A(high)
|
|
// let poly_A_bound_point = poly_A[len + i] + poly_A[len + i] - poly_A[i];
|
|
// let poly_B_bound_point = poly_B[len + i] + poly_B[len + i] - poly_B[i];
|
|
// eval_point_2 += comb_func(&poly_A_bound_point, &poly_B_bound_point);
|
|
// }
|
|
|
|
// let evals = vec![eval_point_0, claim_per_round - eval_point_0, eval_point_2];
|
|
// let poly = UniPoly::from_evals(&evals);
|
|
// let comm_poly = poly.commit(gens_n, &blinds_poly[j]).compress();
|
|
// (poly, comm_poly)
|
|
// };
|
|
|
|
// // append the prover's message to the transcript
|
|
// comm_poly.append_to_transcript(b"comm_poly", transcript);
|
|
// comm_polys.push(comm_poly);
|
|
|
|
// //derive the verifier's challenge for the next round
|
|
// let r_j = transcript.challenge_scalar(b"challenge_nextround");
|
|
|
|
// // bound all tables to the verifier's challenege
|
|
// poly_A.bound_poly_var_top(&r_j);
|
|
// poly_B.bound_poly_var_top(&r_j);
|
|
|
|
// // produce a proof of sum-check and of evaluation
|
|
// let (proof, claim_next_round, comm_claim_next_round) = {
|
|
// let eval = poly.evaluate(&r_j);
|
|
// let comm_eval = eval.commit(&blinds_evals[j], gens_1).compress();
|
|
|
|
// // we need to prove the following under homomorphic commitments:
|
|
// // (1) poly(0) + poly(1) = claim_per_round
|
|
// // (2) poly(r_j) = eval
|
|
|
|
// // Our technique is to leverage dot product proofs:
|
|
// // (1) we can prove: <poly_in_coeffs_form, (2, 1, 1, 1)> = claim_per_round
|
|
// // (2) we can prove: <poly_in_coeffs_form, (1, r_j, r^2_j, ..) = eval
|
|
// // for efficiency we batch them using random weights
|
|
|
|
// // add two claims to transcript
|
|
// comm_claim_per_round.append_to_transcript(b"comm_claim_per_round", transcript);
|
|
// comm_eval.append_to_transcript(b"comm_eval", transcript);
|
|
|
|
// // produce two weights
|
|
// let w = transcript.challenge_vector(b"combine_two_claims_to_one", 2);
|
|
|
|
// // compute a weighted sum of the RHS
|
|
// let target = w[0] * claim_per_round + w[1] * eval;
|
|
// let comm_target = GroupElement::vartime_multiscalar_mul(
|
|
// w.as_slice(),
|
|
// iter::once(&comm_claim_per_round)
|
|
// .chain(iter::once(&comm_eval))
|
|
// .map(|pt| GroupElement::decompress(pt).unwrap())
|
|
// .collect::<Vec<GroupElement>>()
|
|
// .as_slice(),
|
|
// )
|
|
// .compress();
|
|
|
|
// let blind = {
|
|
// let blind_sc = if j == 0 {
|
|
// blind_claim
|
|
// } else {
|
|
// &blinds_evals[j - 1]
|
|
// };
|
|
|
|
// let blind_eval = &blinds_evals[j];
|
|
|
|
// w[0] * blind_sc + w[1] * blind_eval
|
|
// };
|
|
// assert_eq!(target.commit(&blind, gens_1).compress(), comm_target);
|
|
|
|
// let a = {
|
|
// // the vector to use to decommit for sum-check test
|
|
// let a_sc = {
|
|
// let mut a = vec![Scalar::one(); poly.degree() + 1];
|
|
// a[0] += Scalar::one();
|
|
// a
|
|
// };
|
|
|
|
// // the vector to use to decommit for evaluation
|
|
// let a_eval = {
|
|
// let mut a = vec![Scalar::one(); poly.degree() + 1];
|
|
// for j in 1..a.len() {
|
|
// a[j] = a[j - 1] * r_j;
|
|
// }
|
|
// a
|
|
// };
|
|
|
|
// // take weighted sum of the two vectors using w
|
|
// assert_eq!(a_sc.len(), a_eval.len());
|
|
// (0..a_sc.len())
|
|
// .map(|i| w[0] * a_sc[i] + w[1] * a_eval[i])
|
|
// .collect::<Vec<Scalar>>()
|
|
// };
|
|
|
|
// let (proof, _comm_poly, _comm_sc_eval) = DotProductProof::prove(
|
|
// gens_1,
|
|
// gens_n,
|
|
// transcript,
|
|
// random_tape,
|
|
// &poly.as_vec(),
|
|
// &blinds_poly[j],
|
|
// &a,
|
|
// &target,
|
|
// &blind,
|
|
// );
|
|
|
|
// (proof, eval, comm_eval)
|
|
// };
|
|
|
|
// claim_per_round = claim_next_round;
|
|
// comm_claim_per_round = comm_claim_next_round;
|
|
|
|
// proofs.push(proof);
|
|
// r.push(r_j);
|
|
// comm_evals.push(comm_claim_per_round.clone());
|
|
// }
|
|
|
|
// (
|
|
// ZKSumcheckInstanceProof::new(comm_polys, comm_evals, proofs),
|
|
// r,
|
|
// vec![poly_A[0], poly_B[0]],
|
|
// blinds_evals[num_rounds - 1],
|
|
// )
|
|
// }
|
|
|
|
// pub fn prove_cubic_with_additive_term<F>(
|
|
// claim: &Scalar,
|
|
// blind_claim: &Scalar,
|
|
// num_rounds: usize,
|
|
// poly_A: &mut DensePolynomial,
|
|
// poly_B: &mut DensePolynomial,
|
|
// poly_C: &mut DensePolynomial,
|
|
// poly_D: &mut DensePolynomial,
|
|
// comb_func: F,
|
|
// gens_1: &MultiCommitGens,
|
|
// gens_n: &MultiCommitGens,
|
|
// transcript: &mut Transcript,
|
|
// random_tape: &mut RandomTape,
|
|
// ) -> (Self, Vec<Scalar>, Vec<Scalar>, Scalar)
|
|
// where
|
|
// F: Fn(&Scalar, &Scalar, &Scalar, &Scalar) -> Scalar,
|
|
// {
|
|
// let (blinds_poly, blinds_evals) = (
|
|
// random_tape.random_vector(b"blinds_poly", num_rounds),
|
|
// random_tape.random_vector(b"blinds_evals", num_rounds),
|
|
// );
|
|
|
|
// let mut claim_per_round = *claim;
|
|
// let mut comm_claim_per_round = claim_per_round.commit(blind_claim, gens_1).compress();
|
|
|
|
// let mut r: Vec<Scalar> = Vec::new();
|
|
// let mut comm_polys: Vec<CompressedGroup> = Vec::new();
|
|
// let mut comm_evals: Vec<CompressedGroup> = Vec::new();
|
|
// let mut proofs: Vec<DotProductProof> = Vec::new();
|
|
|
|
// for j in 0..num_rounds {
|
|
// let (poly, comm_poly) = {
|
|
// let mut eval_point_0 = Scalar::zero();
|
|
// let mut eval_point_2 = Scalar::zero();
|
|
// let mut eval_point_3 = Scalar::zero();
|
|
|
|
// let len = poly_A.len() / 2;
|
|
// for i in 0..len {
|
|
// // eval 0: bound_func is A(low)
|
|
// eval_point_0 += comb_func(&poly_A[i], &poly_B[i], &poly_C[i], &poly_D[i]);
|
|
|
|
// // eval 2: bound_func is -A(low) + 2*A(high)
|
|
// let poly_A_bound_point = poly_A[len + i] + poly_A[len + i] - poly_A[i];
|
|
// let poly_B_bound_point = poly_B[len + i] + poly_B[len + i] - poly_B[i];
|
|
// let poly_C_bound_point = poly_C[len + i] + poly_C[len + i] - poly_C[i];
|
|
// let poly_D_bound_point = poly_D[len + i] + poly_D[len + i] - poly_D[i];
|
|
// eval_point_2 += comb_func(
|
|
// &poly_A_bound_point,
|
|
// &poly_B_bound_point,
|
|
// &poly_C_bound_point,
|
|
// &poly_D_bound_point,
|
|
// );
|
|
|
|
// // eval 3: bound_func is -2A(low) + 3A(high); computed incrementally with bound_func applied to eval(2)
|
|
// let poly_A_bound_point = poly_A_bound_point + poly_A[len + i] - poly_A[i];
|
|
// let poly_B_bound_point = poly_B_bound_point + poly_B[len + i] - poly_B[i];
|
|
// let poly_C_bound_point = poly_C_bound_point + poly_C[len + i] - poly_C[i];
|
|
// let poly_D_bound_point = poly_D_bound_point + poly_D[len + i] - poly_D[i];
|
|
// eval_point_3 += comb_func(
|
|
// &poly_A_bound_point,
|
|
// &poly_B_bound_point,
|
|
// &poly_C_bound_point,
|
|
// &poly_D_bound_point,
|
|
// );
|
|
// }
|
|
|
|
// let evals = vec![
|
|
// eval_point_0,
|
|
// claim_per_round - eval_point_0,
|
|
// eval_point_2,
|
|
// eval_point_3,
|
|
// ];
|
|
// let poly = UniPoly::from_evals(&evals);
|
|
// let comm_poly = poly.commit(gens_n, &blinds_poly[j]).compress();
|
|
// (poly, comm_poly)
|
|
// };
|
|
|
|
// // append the prover's message to the transcript
|
|
// comm_poly.append_to_transcript(b"comm_poly", transcript);
|
|
// comm_polys.push(comm_poly);
|
|
|
|
// //derive the verifier's challenge for the next round
|
|
// let r_j = transcript.challenge_scalar(b"challenge_nextround");
|
|
|
|
// // bound all tables to the verifier's challenege
|
|
// poly_A.bound_poly_var_top(&r_j);
|
|
// poly_B.bound_poly_var_top(&r_j);
|
|
// poly_C.bound_poly_var_top(&r_j);
|
|
// poly_D.bound_poly_var_top(&r_j);
|
|
|
|
// // produce a proof of sum-check and of evaluation
|
|
// let (proof, claim_next_round, comm_claim_next_round) = {
|
|
// let eval = poly.evaluate(&r_j);
|
|
// let comm_eval = eval.commit(&blinds_evals[j], gens_1).compress();
|
|
|
|
// // we need to prove the following under homomorphic commitments:
|
|
// // (1) poly(0) + poly(1) = claim_per_round
|
|
// // (2) poly(r_j) = eval
|
|
|
|
// // Our technique is to leverage dot product proofs:
|
|
// // (1) we can prove: <poly_in_coeffs_form, (2, 1, 1, 1)> = claim_per_round
|
|
// // (2) we can prove: <poly_in_coeffs_form, (1, r_j, r^2_j, ..) = eval
|
|
// // for efficiency we batch them using random weights
|
|
|
|
// // add two claims to transcript
|
|
// comm_claim_per_round.append_to_transcript(b"comm_claim_per_round", transcript);
|
|
// comm_eval.append_to_transcript(b"comm_eval", transcript);
|
|
|
|
// // produce two weights
|
|
// let w = transcript.challenge_vector(b"combine_two_claims_to_one", 2);
|
|
|
|
// // compute a weighted sum of the RHS
|
|
// let target = w[0] * claim_per_round + w[1] * eval;
|
|
|
|
// let comm_target = GroupElement::vartime_multiscalar_mul(
|
|
// w.as_slice(),
|
|
// iter::once(&comm_claim_per_round)
|
|
// .chain(iter::once(&comm_eval))
|
|
// .map(|pt| GroupElement::decompress(&pt).unwrap())
|
|
// .collect::<Vec<GroupElement>>()
|
|
// .as_slice(),
|
|
// )
|
|
// .compress();
|
|
|
|
// let blind = {
|
|
// let blind_sc = if j == 0 {
|
|
// blind_claim
|
|
// } else {
|
|
// &blinds_evals[j - 1]
|
|
// };
|
|
|
|
// let blind_eval = &blinds_evals[j];
|
|
|
|
// w[0] * blind_sc + w[1] * blind_eval
|
|
// };
|
|
|
|
// let res = target.commit(&blind, gens_1);
|
|
|
|
// assert_eq!(res.compress(), comm_target);
|
|
|
|
// let a = {
|
|
// // the vector to use to decommit for sum-check test
|
|
// let a_sc = {
|
|
// let mut a = vec![Scalar::one(); poly.degree() + 1];
|
|
// a[0] += Scalar::one();
|
|
// a
|
|
// };
|
|
|
|
// // the vector to use to decommit for evaluation
|
|
// let a_eval = {
|
|
// let mut a = vec![Scalar::one(); poly.degree() + 1];
|
|
// for j in 1..a.len() {
|
|
// a[j] = a[j - 1] * r_j;
|
|
// }
|
|
// a
|
|
// };
|
|
|
|
// // take weighted sum of the two vectors using w
|
|
// assert_eq!(a_sc.len(), a_eval.len());
|
|
// (0..a_sc.len())
|
|
// .map(|i| w[0] * a_sc[i] + w[1] * a_eval[i])
|
|
// .collect::<Vec<Scalar>>()
|
|
// };
|
|
|
|
// let (proof, _comm_poly, _comm_sc_eval) = DotProductProof::prove(
|
|
// gens_1,
|
|
// gens_n,
|
|
// transcript,
|
|
// random_tape,
|
|
// &poly.as_vec(),
|
|
// &blinds_poly[j],
|
|
// &a,
|
|
// &target,
|
|
// &blind,
|
|
// );
|
|
|
|
// (proof, eval, comm_eval)
|
|
// };
|
|
|
|
// proofs.push(proof);
|
|
// claim_per_round = claim_next_round;
|
|
// comm_claim_per_round = comm_claim_next_round;
|
|
// r.push(r_j);
|
|
// comm_evals.push(comm_claim_per_round.clone());
|
|
// }
|
|
|
|
// (
|
|
// ZKSumcheckInstanceProof::new(comm_polys, comm_evals, proofs),
|
|
// r,
|
|
// vec![poly_A[0], poly_B[0], poly_C[0], poly_D[0]],
|
|
// blinds_evals[num_rounds - 1],
|
|
// )
|
|
// }
|
|
// }
|