zec
/
halo2
mirror of https://github.com/zcash/halo2.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Get queires for proving

This commit is contained in:
Eduard S. 2023-12-15 14:10:34 +01:00
parent 50e7354c50
commit 98759c33cd
3 changed files with 132 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
halo2_proofs/src/plonk/circuit.rs
View File

@ -35,7 +35,6 @@ pub struct Column<C: ColumnType> {
}
impl<C: ColumnType> Column<C> {
#[cfg(test)]
pub(crate) fn new(index: usize, column_type: C) -> Self {
Column { index, column_type }
}
@ -1508,6 +1507,31 @@ impl<F: Field, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> IntoIterato
}
}
/// GateV2Backend
#[derive(Clone, Debug)]
pub struct GateV2Backend<F: Field> {
name: String,
constraint_names: Vec<String>,
polys: Vec<Expression<F>>,
}
impl<F: Field> GateV2Backend<F> {
/// Returns the gate name.
pub fn name(&self) -> &str {
self.name.as_str()
}
/// Returns the name of the constraint at index `constraint_index`.
pub fn constraint_name(&self, constraint_index: usize) -> &str {
self.constraint_names[constraint_index].as_str()
}
/// Returns constraints of this gate
pub fn polynomials(&self) -> &[Expression<F>] {
&self.polys
}
}
/// Gate
#[derive(Clone, Debug)]
pub struct Gate<F: Field> {
@ -1585,7 +1609,7 @@ pub struct ConstraintSystemV2Backend<F: Field> {
/// fixed column that they were compressed into. This is just used by dev
/// tooling right now.
// pub(crate) selector_map: Vec<Column<Fixed>>,
pub(crate) gates: Vec<Gate<F>>,
pub(crate) gates: Vec<GateV2Backend<F>>,
// pub(crate) advice_queries: Vec<(Column<Advice>, Rotation)>,
// Contains an integer for each advice column
// identifying how many distinct queries it has

133
halo2_proofs/src/plonk/prover.rs
View File

@ -8,8 +8,8 @@ use std::{collections::HashMap, iter};
use super::{
circuit::{
sealed::{self},
Advice, Any, Assignment, Challenge, Circuit, Column, CompiledCircuitV2, ConstraintSystem,
ConstraintSystemV2Backend, Fixed, FloorPlanner, Instance, Selector,
Advice, Any, Assignment, Challenge, Circuit, Column, ConstraintSystem,
ConstraintSystemV2Backend, Expression, Fixed, FloorPlanner, Instance, Selector,
},
lookup, permutation, shuffle, vanishing, ChallengeBeta, ChallengeGamma, ChallengeTheta,
ChallengeX, ChallengeY, Error, ProvingKey, ProvingKeyV2,
@ -55,20 +55,107 @@ pub struct ProverV2<
R: RngCore,
T: TranscriptWrite<Scheme::Curve, E>,
> {
// Circuit and setup fields
params: &'params Scheme::ParamsProver,
pk: &'a ProvingKeyV2<Scheme::Curve>,
cs: &'a ConstraintSystemV2Backend<Scheme::Scalar>,
advice_queries: Vec<(Column<Advice>, Rotation)>,
instance_queries: Vec<(Column<Instance>, Rotation)>,
fixed_queries: Vec<(Column<Fixed>, Rotation)>,
phases: Vec<u8>,
// State
instance: Vec<InstanceSingle<Scheme::Curve>>,
rng: R,
transcript: T,
advice: Vec<AdviceSingle<Scheme::Curve, LagrangeCoeff>>,
challenges: HashMap<usize, Scheme::Scalar>,
next_phase_index: usize,
_marker: std::marker::PhantomData<(Scheme, P, E, R, T)>,
rng: R,
transcript: T,
_marker: std::marker::PhantomData<(P, E)>,
}
struct Queries {
advice: Vec<(Column<Advice>, Rotation)>,
instance: Vec<(Column<Instance>, Rotation)>,
fixed: Vec<(Column<Fixed>, Rotation)>,
}
struct QueriesSet {
advice: BTreeSet<(Column<Advice>, Rotation)>,
instance: BTreeSet<(Column<Instance>, Rotation)>,
fixed: BTreeSet<(Column<Fixed>, Rotation)>,
}
fn collect_queries<F: Field>(expr: &Expression<F>, queries: &mut QueriesSet) {
match expr {
Expression::Constant(_) => (),
Expression::Selector(_selector) => {
panic!("no Selector should arrive to the Backend");
}
Expression::Fixed(query) => {
queries
.fixed
.insert((Column::new(query.column_index, Fixed), query.rotation));
}
Expression::Advice(query) => {
queries.advice.insert((
Column::new(query.column_index, Advice { phase: query.phase }),
query.rotation,
));
}
Expression::Instance(query) => {
queries
.instance
.insert((Column::new(query.column_index, Instance), query.rotation));
}
Expression::Challenge(_) => (),
Expression::Negated(a) => collect_queries(a, queries),
Expression::Sum(a, b) => {
collect_queries(a, queries);
collect_queries(b, queries);
}
Expression::Product(a, b) => {
collect_queries(a, queries);
collect_queries(b, queries);
}
Expression::Scaled(a, _) => collect_queries(a, queries),
};
}
fn get_all_queries<F: Field>(cs: &ConstraintSystemV2Backend<F>) -> Queries {
let mut queries = QueriesSet {
advice: BTreeSet::new(),
instance: BTreeSet::new(),
fixed: BTreeSet::new(),
};
for gate in &cs.gates {
for expr in gate.polynomials() {
collect_queries(expr, &mut queries);
}
}
for lookup in &cs.lookups {
for expr in lookup
.input_expressions
.iter()
.chain(lookup.table_expressions.iter())
{
collect_queries(expr, &mut queries);
}
}
for shuffle in &cs.shuffles {
for expr in shuffle
.input_expressions
.iter()
.chain(shuffle.shuffle_expressions.iter())
{
collect_queries(expr, &mut queries);
}
}
Queries {
advice: queries.advice.into_iter().collect(),
instance: queries.instance.into_iter().collect(),
fixed: queries.fixed.into_iter().collect(),
}
}
impl<
@ -85,7 +172,6 @@ impl<
pub fn new(
params: &'params Scheme::ParamsProver,
pk: &'a ProvingKeyV2<Scheme::Curve>,
circuit: &'a CompiledCircuitV2<Scheme::Scalar>,
instances: &[&[&[Scheme::Scalar]]],
rng: R,
mut transcript: T,
@ -94,22 +180,19 @@ impl<
where
Scheme::Scalar: WithSmallOrderMulGroup<3> + FromUniformBytes<64>,
{
// TODO: We have cs duplicated in circuit.cs and pk.vk.cs. Can we dedup them?
for instance in instances.iter() {
if instance.len() != pk.vk.cs.num_instance_columns {
return Err(Error::InvalidInstances);
}
}
// TODO(Edu): Calculate advice_queries, fixed_queries, instance_queries from the gates and
// lookup expressions.
let queries = get_all_queries(&pk.vk.cs);
// Hash verification key into transcript
pk.vk.hash_into(&mut transcript)?;
let meta = &circuit.cs;
let phases = circuit.cs.phases();
let meta = &pk.vk.cs;
let phases = meta.phases();
let domain = &pk.vk.domain;
@ -182,11 +265,10 @@ impl<
Ok(ProverV2 {
params,
cs: &circuit.cs,
pk,
advice_queries: todo!(),
instance_queries: todo!(),
fixed_queries: todo!(),
advice_queries: queries.advice,
instance_queries: queries.instance,
fixed_queries: queries.fixed,
phases,
instance,
rng,
@ -220,7 +302,7 @@ impl<
}
let params = self.params;
let meta = self.cs;
let meta = &self.pk.vk.cs;
let transcript = &mut self.transcript;
let mut rng = &mut self.rng;
@ -262,7 +344,6 @@ impl<
}
let mut commit_phase_fn = |advice: &mut AdviceSingle<Scheme::Curve, LagrangeCoeff>,
challenges: &mut HashMap<usize, Scheme::Scalar>,
witness: Vec<
Option<Polynomial<Assigned<Scheme::Scalar>, LagrangeCoeff>>,
>|
@ -325,7 +406,7 @@ impl<
};
for (witness, advice) in witness.into_iter().zip(advice.iter_mut()) {
commit_phase_fn(advice, challenges, witness)?;
commit_phase_fn(advice, witness)?;
}
for (index, phase) in meta.challenge_phase.iter().enumerate() {
@ -346,7 +427,7 @@ impl<
Scheme::Scalar: WithSmallOrderMulGroup<3> + FromUniformBytes<64>,
{
let params = self.params;
let meta = self.cs;
let meta = &self.pk.vk.cs;
let pk = self.pk;
let domain = &self.pk.vk.domain;
@ -369,9 +450,7 @@ impl<
|instance: &InstanceSingle<Scheme::Curve>,
advice: &AdviceSingle<Scheme::Curve, LagrangeCoeff>|
-> Result<Vec<lookup::prover::Permuted<Scheme::Curve>>, Error> {
pk.vk
.cs
.lookups
meta.lookups
.iter()
.map(|lookup| {
lookup.commit_permuted_v2(
@ -409,7 +488,7 @@ impl<
.iter()
.zip(advice.iter())
.map(|(instance, advice)| {
pk.vk.cs.permutation.commit_v2(
meta.permutation.commit_v2(
params,
pk,
&pk.permutation,
@ -442,9 +521,7 @@ impl<
.zip(advice.iter())
.map(|(instance, advice)| -> Result<Vec<_>, _> {
// Compress expressions for each shuffle
pk.vk
.cs
.shuffles
meta.shuffles
.iter()
.map(|shuffle| {
shuffle.commit_product_v2(

2
halo2_proofs/src/poly.rs
View File

@ -303,7 +303,7 @@ impl<'a, F: Field, B: Basis> Sub<F> for &'a Polynomial<F, B> {
/// Describes the relative rotation of a vector. Negative numbers represent
/// reverse (leftmost) rotations and positive numbers represent forward (rightmost)
/// rotations. Zero represents no rotation.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct Rotation(pub i32);
impl Rotation {