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

Merge 521bc3d2d8 into 76b3f892a9

This commit is contained in:
str4d 2023-06-06 18:46:42 +00:00 committed by GitHub
parent 76b3f892a9 521bc3d2d8
commit 84c71b27a0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
54 changed files with 335 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
halo2_gadgets/benches/poseidon.rs
View File

@ -4,7 +4,7 @@ use halo2_proofs::{
pasta::Fp,
plonk::{
create_proof, keygen_pk, keygen_vk, verify_proof, Advice, Circuit, Column,
ConstraintSystem, Error, Instance, SingleVerifier,
ConstraintSystemBuilder, Error, Instance, SingleVerifier,
},
poly::commitment::Params,
transcript::{Blake2bRead, Blake2bWrite, Challenge255},
@ -52,7 +52,7 @@ where
}
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Self::Config {
let state = (0..WIDTH).map(|_| meta.advice_column()).collect::<Vec<_>>();
let expected = meta.instance_column();
meta.enable_equality(expected);

4
halo2_gadgets/benches/sha256.rs
View File

@ -2,7 +2,7 @@ use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
pasta::{pallas, EqAffine},
plonk::{
create_proof, keygen_pk, keygen_vk, verify_proof, Circuit, ConstraintSystem, Error,
create_proof, keygen_pk, keygen_vk, verify_proof, Circuit, ConstraintSystemBuilder, Error,
SingleVerifier,
},
poly::commitment::Params,
@ -32,7 +32,7 @@ fn bench(name: &str, k: u32, c: &mut Criterion) {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
Table16Chip::configure(meta)
}

4
halo2_gadgets/src/ecc.rs
View File

@ -583,7 +583,7 @@ pub(crate) mod tests {
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
dev::MockProver,
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
use lazy_static::lazy_static;
use pasta_curves::pallas;
@ -736,7 +736,7 @@ pub(crate) mod tests {
MyCircuit { test_errors: false }
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
let advices = [
meta.advice_column(),
meta.advice_column(),

4
halo2_gadgets/src/ecc/chip.rs
View File

@ -11,7 +11,7 @@ use ff::PrimeField;
use group::prime::PrimeCurveAffine;
use halo2_proofs::{
circuit::{AssignedCell, Chip, Layouter, Value},
plonk::{Advice, Assigned, Column, ConstraintSystem, Error, Fixed},
plonk::{Advice, Assigned, Column, ConstraintSystemBuilder, Error, Fixed},
};
use pasta_curves::{arithmetic::CurveAffine, pallas};
@ -261,7 +261,7 @@ impl<FixedPoints: super::FixedPoints<pallas::Affine>> EccChip<FixedPoints> {
/// All columns in `advices` will be equality-enabled.
#[allow(non_snake_case)]
pub fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
advices: [Column<Advice>; 10],
lagrange_coeffs: [Column<Fixed>; 8],
range_check: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,

8
halo2_gadgets/src/ecc/chip/add.rs
View File

@ -3,7 +3,9 @@ use super::EccPoint;
use group::ff::PrimeField;
use halo2_proofs::{
circuit::Region,
plonk::{Advice, Assigned, Column, ConstraintSystem, Constraints, Error, Expression, Selector},
plonk::{
Advice, Assigned, Column, ConstraintSystemBuilder, Constraints, Error, Expression, Selector,
},
poly::Rotation,
};
use pasta_curves::pallas;
@ -36,7 +38,7 @@ pub struct Config {
impl Config {
#[allow(clippy::too_many_arguments)]
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
x_p: Column<Advice>,
y_p: Column<Advice>,
x_qr: Column<Advice>,
@ -74,7 +76,7 @@ impl Config {
[self.x_qr, self.y_qr].into_iter().collect()
}
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// https://p.z.cash/halo2-0.1:ecc-complete-addition
meta.create_gate("complete addition", |meta| {
let q_add = meta.query_selector(self.q_add);

6
halo2_gadgets/src/ecc/chip/add_incomplete.rs
View File

@ -3,7 +3,7 @@ use std::collections::HashSet;
use super::NonIdentityEccPoint;
use halo2_proofs::{
circuit::Region,
plonk::{Advice, Column, ConstraintSystem, Constraints, Error, Selector},
plonk::{Advice, Column, ConstraintSystemBuilder, Constraints, Error, Selector},
poly::Rotation,
};
use pasta_curves::pallas;
@ -23,7 +23,7 @@ pub struct Config {
impl Config {
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
x_p: Column<Advice>,
y_p: Column<Advice>,
x_qr: Column<Advice>,
@ -53,7 +53,7 @@ impl Config {
.collect()
}
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// https://p.z.cash/halo2-0.1:ecc-incomplete-addition
meta.create_gate("incomplete addition", |meta| {
let q_add_incomplete = meta.query_selector(self.q_add_incomplete);

6
halo2_gadgets/src/ecc/chip/mul.rs
View File

@ -11,7 +11,7 @@ use std::{
use ff::{Field, PrimeField};
use halo2_proofs::{
circuit::{AssignedCell, Layouter, Region, Value},
plonk::{Advice, Assigned, Column, ConstraintSystem, Constraints, Error, Selector},
plonk::{Advice, Assigned, Column, ConstraintSystemBuilder, Constraints, Error, Selector},
poly::Rotation,
};
use uint::construct_uint;
@ -63,7 +63,7 @@ pub struct Config {
impl Config {
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
add_config: add::Config,
lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
advices: [Column<Advice>; 10],
@ -126,7 +126,7 @@ impl Config {
config
}
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// If `lsb` is 0, (x, y) = (x_p, -y_p). If `lsb` is 1, (x, y) = (0,0).
// https://p.z.cash/halo2-0.1:ecc-var-mul-lsb-gate?partial
meta.create_gate("LSB check", |meta| {

6
halo2_gadgets/src/ecc/chip/mul/complete.rs
View File

@ -4,7 +4,7 @@ use crate::utilities::{bool_check, ternary};
use halo2_proofs::{
circuit::{Region, Value},
plonk::{Advice, Column, ConstraintSystem, Constraints, Error, Expression, Selector},
plonk::{Advice, Column, ConstraintSystemBuilder, Constraints, Error, Expression, Selector},
poly::Rotation,
};
@ -22,7 +22,7 @@ pub struct Config {
impl Config {
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
z_complete: Column<Advice>,
add_config: add::Config,
) -> Self {
@ -43,7 +43,7 @@ impl Config {
/// This is used to check the bits used in complete addition, since the incomplete
/// addition gate (controlled by `q_mul`) already checks scalar decomposition for
/// the other bits.
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// | y_p | z_complete |
// --------------------
// | y_p | z_{i + 1} |

7
halo2_gadgets/src/ecc/chip/mul/incomplete.rs
View File

@ -6,7 +6,8 @@ use group::ff::PrimeField;
use halo2_proofs::{
circuit::{Region, Value},
plonk::{
Advice, Column, ConstraintSystem, Constraints, Error, Expression, Selector, VirtualCells,
Advice, Column, ConstraintSystemBuilder, Constraints, Error, Expression, Selector,
VirtualCells,
},
poly::Rotation,
};
@ -73,7 +74,7 @@ pub(crate) struct Config<const NUM_BITS: usize> {
impl<const NUM_BITS: usize> Config<NUM_BITS> {
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
z: Column<Advice>,
x_a: Column<Advice>,
x_p: Column<Advice>,
@ -104,7 +105,7 @@ impl<const NUM_BITS: usize> Config<NUM_BITS> {
}
// Gate for incomplete addition part of variable-base scalar multiplication.
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// Closure to compute x_{R,i} = λ_{1,i}^2 - x_{A,i} - x_{P,i}
let x_r = |meta: &mut VirtualCells<pallas::Base>, rotation: Rotation| {
self.double_and_add.x_r(meta, rotation)

8
halo2_gadgets/src/ecc/chip/mul/overflow.rs
View File

@ -7,7 +7,9 @@ use group::ff::PrimeField;
use halo2_proofs::circuit::AssignedCell;
use halo2_proofs::{
circuit::Layouter,
plonk::{Advice, Assigned, Column, ConstraintSystem, Constraints, Error, Expression, Selector},
plonk::{
Advice, Assigned, Column, ConstraintSystemBuilder, Constraints, Error, Expression, Selector,
},
poly::Rotation,
};
use pasta_curves::pallas;
@ -26,7 +28,7 @@ pub struct Config {
impl Config {
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
advices: [Column<Advice>; 3],
) -> Self {
@ -45,7 +47,7 @@ impl Config {
config
}
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// https://p.z.cash/halo2-0.1:ecc-var-mul-overflow
meta.create_gate("overflow checks", |meta| {
let q_mul_overflow = meta.query_selector(self.q_mul_overflow);

6
halo2_gadgets/src/ecc/chip/mul_fixed.rs
View File

@ -13,7 +13,7 @@ use group::{
use halo2_proofs::{
circuit::{AssignedCell, Region, Value},
plonk::{
Advice, Column, ConstraintSystem, Constraints, Error, Expression, Fixed, Selector,
Advice, Column, ConstraintSystemBuilder, Constraints, Error, Expression, Fixed, Selector,
VirtualCells,
},
poly::Rotation,
@ -54,7 +54,7 @@ pub struct Config<FixedPoints: super::FixedPoints<pallas::Affine>> {
impl<FixedPoints: super::FixedPoints<pallas::Affine>> Config<FixedPoints> {
#[allow(clippy::too_many_arguments)]
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
lagrange_coeffs: [Column<Fixed>; H],
window: Column<Advice>,
u: Column<Advice>,
@ -112,7 +112,7 @@ impl<FixedPoints: super::FixedPoints<pallas::Affine>> Config<FixedPoints> {
/// This gate is not used in the mul_fixed::full_width helper, since the full-width
/// scalar is witnessed directly as three-bit windows instead of being decomposed
/// via a running sum.
fn running_sum_coords_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn running_sum_coords_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
meta.create_gate("Running sum coordinates check", |meta| {
let q_mul_fixed_running_sum =
meta.query_selector(self.running_sum_config.q_range_check());

6
halo2_gadgets/src/ecc/chip/mul_fixed/base_field_elem.rs
View File

@ -10,7 +10,7 @@ use crate::{
use group::ff::PrimeField;
use halo2_proofs::{
circuit::{AssignedCell, Layouter},
plonk::{Advice, Column, ConstraintSystem, Constraints, Error, Expression, Selector},
plonk::{Advice, Column, ConstraintSystemBuilder, Constraints, Error, Expression, Selector},
poly::Rotation,
};
use pasta_curves::pallas;
@ -27,7 +27,7 @@ pub struct Config<Fixed: FixedPoints<pallas::Affine>> {
impl<Fixed: FixedPoints<pallas::Affine>> Config<Fixed> {
pub(crate) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
canon_advices: [Column<Advice>; 3],
lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
super_config: super::Config<Fixed>,
@ -56,7 +56,7 @@ impl<Fixed: FixedPoints<pallas::Affine>> Config<Fixed> {
config
}
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// Check that the base field element is canonical.
// https://p.z.cash/halo2-0.1:ecc-fixed-mul-base-canonicity
meta.create_gate("Canonicity checks", |meta| {

6
halo2_gadgets/src/ecc/chip/mul_fixed/full_width.rs
View File

@ -5,7 +5,7 @@ use arrayvec::ArrayVec;
use ff::PrimeField;
use halo2_proofs::{
circuit::{AssignedCell, Layouter, Region, Value},
plonk::{ConstraintSystem, Constraints, Error, Selector},
plonk::{ConstraintSystemBuilder, Constraints, Error, Selector},
poly::Rotation,
};
use pasta_curves::pallas;
@ -18,7 +18,7 @@ pub struct Config<Fixed: FixedPoints<pallas::Affine>> {
impl<Fixed: FixedPoints<pallas::Affine>> Config<Fixed> {
pub(crate) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
super_config: super::Config<Fixed>,
) -> Self {
let config = Self {
@ -31,7 +31,7 @@ impl<Fixed: FixedPoints<pallas::Affine>> Config<Fixed> {
config
}
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// Check that each window `k` is within 3 bits
// https://p.z.cash/halo2-0.1:ecc-fixed-mul-full-word
meta.create_gate("Full-width fixed-base scalar mul", |meta| {

10
halo2_gadgets/src/ecc/chip/mul_fixed/short.rs
View File

@ -5,7 +5,7 @@ use crate::{ecc::chip::MagnitudeSign, utilities::bool_check};
use halo2_proofs::{
circuit::{Layouter, Region},
plonk::{ConstraintSystem, Constraints, Error, Expression, Selector},
plonk::{ConstraintSystemBuilder, Constraints, Error, Expression, Selector},
poly::Rotation,
};
use pasta_curves::pallas;
@ -19,7 +19,7 @@ pub struct Config<Fixed: FixedPoints<pallas::Affine>> {
impl<Fixed: FixedPoints<pallas::Affine>> Config<Fixed> {
pub(crate) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
super_config: super::Config<Fixed>,
) -> Self {
let config = Self {
@ -32,7 +32,7 @@ impl<Fixed: FixedPoints<pallas::Affine>> Config<Fixed> {
config
}
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
// Gate contains the following constraints:
// - https://p.z.cash/halo2-0.1:ecc-fixed-mul-short-msb
// - https://p.z.cash/halo2-0.1:ecc-fixed-mul-short-conditional-neg
@ -409,7 +409,7 @@ pub mod tests {
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner},
dev::{FailureLocation, MockProver, VerifyFailure},
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
#[derive(Default)]
@ -432,7 +432,7 @@ pub mod tests {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
let advices = [
meta.advice_column(),
meta.advice_column(),

8
halo2_gadgets/src/ecc/chip/witness_point.rs
View File

@ -5,8 +5,8 @@ use group::prime::PrimeCurveAffine;
use halo2_proofs::{
circuit::{AssignedCell, Region, Value},
plonk::{
Advice, Assigned, Column, ConstraintSystem, Constraints, Error, Expression, Selector,
VirtualCells,
Advice, Assigned, Column, ConstraintSystemBuilder, Constraints, Error, Expression,
Selector, VirtualCells,
},
poly::Rotation,
};
@ -29,7 +29,7 @@ pub struct Config {
impl Config {
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
x: Column<Advice>,
y: Column<Advice>,
) -> Self {
@ -45,7 +45,7 @@ impl Config {
config
}
fn create_gate(&self, meta: &mut ConstraintSystem<pallas::Base>) {
fn create_gate(&self, meta: &mut ConstraintSystemBuilder<pallas::Base>) {
let curve_eqn = |meta: &mut VirtualCells<pallas::Base>| {
let x = meta.query_advice(self.x, Rotation::cur());
let y = meta.query_advice(self.y, Rotation::cur());

11
halo2_gadgets/src/poseidon/pow5.rs
View File

@ -5,7 +5,8 @@ use group::ff::Field;
use halo2_proofs::{
circuit::{AssignedCell, Cell, Chip, Layouter, Region, Value},
plonk::{
Advice, Any, Column, ConstraintSystem, Constraints, Error, Expression, Fixed, Selector,
Advice, Any, Column, ConstraintSystemBuilder, Constraints, Error, Expression, Fixed,
Selector,
},
poly::Rotation,
};
@ -54,7 +55,7 @@ impl<F: Field, const WIDTH: usize, const RATE: usize> Pow5Chip<F, WIDTH, RATE> {
// needs to be known wherever we implement the hashing gadget, but it isn't strictly
// necessary for the permutation.
pub fn configure<S: Spec<F, WIDTH, RATE>>(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
state: [Column<Advice>; WIDTH],
partial_sbox: Column<Advice>,
rc_a: [Column<Fixed>; WIDTH],
@ -597,7 +598,7 @@ mod tests {
circuit::{Layouter, SimpleFloorPlanner, Value},
dev::MockProver,
pasta::Fp,
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
use pasta_curves::pallas;
use rand::rngs::OsRng;
@ -624,7 +625,7 @@ mod tests {
PermuteCircuit::<S, WIDTH, RATE>(PhantomData)
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Pow5Config<Fp, WIDTH, RATE> {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Pow5Config<Fp, WIDTH, RATE> {
let state = (0..WIDTH).map(|_| meta.advice_column()).collect::<Vec<_>>();
let partial_sbox = meta.advice_column();
@ -743,7 +744,7 @@ mod tests {
}
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Pow5Config<Fp, WIDTH, RATE> {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Pow5Config<Fp, WIDTH, RATE> {
let state = (0..WIDTH).map(|_| meta.advice_column()).collect::<Vec<_>>();
let partial_sbox = meta.advice_column();

8
halo2_gadgets/src/sha256/table16.rs
View File

@ -5,7 +5,7 @@ use super::Sha256Instructions;
use halo2_proofs::{
circuit::{AssignedCell, Chip, Layouter, Region, Value},
pasta::pallas,
plonk::{Advice, Any, Assigned, Column, ConstraintSystem, Error},
plonk::{Advice, Any, Assigned, Column, ConstraintSystemBuilder, Error},
};
mod compression;
@ -266,7 +266,7 @@ impl Table16Chip {
/// Configures a circuit to include this chip.
pub fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
) -> <Self as Chip<pallas::Base>>::Config {
// Columns required by this chip:
let message_schedule = meta.advice_column();
@ -457,7 +457,7 @@ mod tests {
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner},
pasta::pallas,
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
#[test]
@ -473,7 +473,7 @@ mod tests {
MyCircuit {}
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
Table16Chip::configure(meta)
}

8
halo2_gadgets/src/sha256/table16/compression.rs
View File

@ -6,7 +6,7 @@ use super::{
use halo2_proofs::{
circuit::{Layouter, Value},
pasta::pallas,
plonk::{Advice, Column, ConstraintSystem, Error, Selector},
plonk::{Advice, Column, ConstraintSystemBuilder, Error, Selector},
poly::Rotation,
};
use std::convert::TryInto;
@ -457,7 +457,7 @@ impl Table16Assignment for CompressionConfig {}
impl CompressionConfig {
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
lookup: SpreadInputs,
message_schedule: Column<Advice>,
extras: [Column<Advice>; 6],
@ -944,7 +944,7 @@ mod tests {
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
pasta::pallas,
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
#[test]
@ -959,7 +959,7 @@ mod tests {
MyCircuit {}
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
Table16Chip::configure(meta)
}

8
halo2_gadgets/src/sha256/table16/message_schedule.rs
View File

@ -4,7 +4,7 @@ use super::{super::BLOCK_SIZE, AssignedBits, BlockWord, SpreadInputs, Table16Ass
use halo2_proofs::{
circuit::Layouter,
pasta::pallas,
plonk::{Advice, Column, ConstraintSystem, Error, Selector},
plonk::{Advice, Column, ConstraintSystemBuilder, Error, Selector},
poly::Rotation,
};
@ -71,7 +71,7 @@ impl MessageScheduleConfig {
/// itself.
#[allow(clippy::many_single_char_names)]
pub(super) fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
lookup: SpreadInputs,
message_schedule: Column<Advice>,
extras: [Column<Advice>; 6],
@ -401,7 +401,7 @@ mod tests {
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
pasta::pallas,
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
#[test]
@ -416,7 +416,7 @@ mod tests {
MyCircuit {}
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
Table16Chip::configure(meta)
}

8
halo2_gadgets/src/sha256/table16/spread_table.rs
View File

@ -4,7 +4,7 @@ use group::ff::{Field, PrimeField};
use halo2_proofs::{
circuit::{Chip, Layouter, Region, Value},
pasta::pallas,
plonk::{Advice, Column, ConstraintSystem, Error, TableColumn},
plonk::{Advice, Column, ConstraintSystemBuilder, Error, TableColumn},
poly::Rotation,
};
use std::convert::TryInto;
@ -182,7 +182,7 @@ impl<F: Field> Chip<F> for SpreadTableChip<F> {
impl<F: PrimeField> SpreadTableChip<F> {
pub fn configure(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
input_tag: Column<Advice>,
input_dense: Column<Advice>,
input_spread: Column<Advice>,
@ -298,7 +298,7 @@ mod tests {
circuit::{Layouter, SimpleFloorPlanner, Value},
dev::MockProver,
pasta::Fp,
plonk::{Advice, Circuit, Column, ConstraintSystem, Error},
plonk::{Advice, Circuit, Column, ConstraintSystemBuilder, Error},
};
#[test]
@ -317,7 +317,7 @@ mod tests {
MyCircuit {}
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
let input_tag = meta.advice_column();
let input_dense = meta.advice_column();
let input_spread = meta.advice_column();

4
halo2_gadgets/src/sinsemilla.rs
View File

@ -456,7 +456,7 @@ pub(crate) mod tests {
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
dev::MockProver,
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
use rand::rngs::OsRng;
@ -532,7 +532,7 @@ pub(crate) mod tests {
}
#[allow(non_snake_case)]
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
let advices = [
meta.advice_column(),
meta.advice_column(),

4
halo2_gadgets/src/sinsemilla/chip.rs
View File

@ -16,7 +16,7 @@ use std::marker::PhantomData;
use halo2_proofs::{
circuit::{AssignedCell, Chip, Layouter, Value},
plonk::{
Advice, Column, ConstraintSystem, Constraints, Error, Expression, Fixed, Selector,
Advice, Column, ConstraintSystemBuilder, Constraints, Error, Expression, Fixed, Selector,
TableColumn, VirtualCells,
},
poly::Rotation,
@ -149,7 +149,7 @@ where
#[allow(clippy::too_many_arguments)]
#[allow(non_snake_case)]
pub fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
advices: [Column<Advice>; 5],
witness_pieces: Column<Advice>,
fixed_y_q: Column<Fixed>,

4
halo2_gadgets/src/sinsemilla/chip/generator_table.rs
View File

@ -1,7 +1,7 @@
use group::ff::PrimeField;
use halo2_proofs::{
circuit::{Layouter, Value},
plonk::{ConstraintSystem, Error, Expression, TableColumn},
plonk::{ConstraintSystemBuilder, Error, Expression, TableColumn},
poly::Rotation,
};
@ -24,7 +24,7 @@ impl GeneratorTableConfig {
/// this specific configuration sets up Sinsemilla-specific constraints
/// controlled by `q_sinsemilla`, and would likely not apply to other chips.
pub fn configure<Hash, Commit, F>(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
config: super::SinsemillaConfig<Hash, Commit, F>,
) where
Hash: HashDomains<pallas::Affine>,

4
halo2_gadgets/src/sinsemilla/merkle.rs
View File

@ -192,7 +192,7 @@ pub mod tests {
circuit::{Layouter, SimpleFloorPlanner, Value},
dev::MockProver,
pasta::pallas,
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
use rand::{rngs::OsRng, RngCore};
@ -218,7 +218,7 @@ pub mod tests {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
let advices = [
meta.advice_column(),
meta.advice_column(),

4
halo2_gadgets/src/sinsemilla/merkle/chip.rs
View File

@ -2,7 +2,7 @@
use halo2_proofs::{
circuit::{AssignedCell, Chip, Layouter, Value},
plonk::{Advice, Column, ConstraintSystem, Constraints, Error, Selector},
plonk::{Advice, Column, ConstraintSystemBuilder, Constraints, Error, Selector},
poly::Rotation,
};
use pasta_curves::pallas;
@ -86,7 +86,7 @@ where
{
/// Configures the [`MerkleChip`].
pub fn configure(
meta: &mut ConstraintSystem<pallas::Base>,
meta: &mut ConstraintSystemBuilder<pallas::Base>,
sinsemilla_config: SinsemillaConfig<Hash, Commit, F>,
) -> MerkleConfig<Hash, Commit, F> {
// All five advice columns are equality-enabled by SinsemillaConfig.

4
halo2_gadgets/src/utilities.rs
View File

@ -244,7 +244,7 @@ mod tests {
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner},
dev::{FailureLocation, MockProver, VerifyFailure},
plonk::{Any, Circuit, ConstraintSystem, Constraints, Error, Selector},
plonk::{Any, Circuit, ConstraintSystemBuilder, Constraints, Error, Selector},
poly::Rotation,
};
use pasta_curves::pallas;
@ -276,7 +276,7 @@ mod tests {
MyCircuit(self.0)
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<pallas::Base>) -> Self::Config {
let selector = meta.selector();
let advice = meta.advice_column();

8
halo2_gadgets/src/utilities/cond_swap.rs
View File

@ -5,7 +5,7 @@ use super::{bool_check, ternary, UtilitiesInstructions};
use group::ff::{Field, PrimeField};
use halo2_proofs::{
circuit::{AssignedCell, Chip, Layouter, Value},
plonk::{Advice, Column, ConstraintSystem, Constraints, Error, Selector},
plonk::{Advice, Column, ConstraintSystemBuilder, Constraints, Error, Selector},
poly::Rotation,
};
use std::marker::PhantomData;
@ -130,7 +130,7 @@ impl<F: PrimeField> CondSwapChip<F> {
///
/// `advices[0]` will be equality-enabled.
pub fn configure(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
advices: [Column<Advice>; 5],
) -> CondSwapConfig {
let a = advices[0];
@ -200,7 +200,7 @@ mod tests {
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
dev::MockProver,
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
use pasta_curves::pallas::Base;
use rand::rngs::OsRng;
@ -222,7 +222,7 @@ mod tests {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
let advices = [
meta.advice_column(),
meta.advice_column(),

8
halo2_gadgets/src/utilities/decompose_running_sum.rs
View File

@ -25,7 +25,7 @@
use ff::PrimeFieldBits;
use halo2_proofs::{
circuit::{AssignedCell, Region, Value},
plonk::{Advice, Column, ConstraintSystem, Constraints, Error, Selector},
plonk::{Advice, Column, ConstraintSystemBuilder, Constraints, Error, Selector},
poly::Rotation,
};
@ -68,7 +68,7 @@ impl<F: PrimeFieldBits, const WINDOW_NUM_BITS: usize> RunningSumConfig<F, WINDOW
///
/// `z` will be equality-enabled.
pub fn configure(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
q_range_check: Selector,
z: Column<Advice>,
) -> Self {
@ -212,7 +212,7 @@ mod tests {
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner},
dev::{FailureLocation, MockProver, VerifyFailure},
plonk::{Any, Circuit, ConstraintSystem, Error},
plonk::{Any, Circuit, ConstraintSystemBuilder, Error},
};
use pasta_curves::pallas;
use rand::rngs::OsRng;
@ -252,7 +252,7 @@ mod tests {
}
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
let z = meta.advice_column();
let q_range_check = meta.selector();
let constants = meta.fixed_column();

12
halo2_gadgets/src/utilities/lookup_range_check.rs
View File

@ -3,7 +3,7 @@
use halo2_proofs::{
circuit::{AssignedCell, Layouter, Region},
plonk::{Advice, Column, ConstraintSystem, Constraints, Error, Selector, TableColumn},
plonk::{Advice, Column, ConstraintSystemBuilder, Constraints, Error, Selector, TableColumn},
poly::Rotation,
};
use std::{convert::TryInto, marker::PhantomData};
@ -78,7 +78,7 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
///
/// Both the `running_sum` and `constants` columns will be equality-enabled.
pub fn configure(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
running_sum: Column<Advice>,
table_idx: TableColumn,
) -> Self {
@ -176,7 +176,7 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
/// Range check on an existing cell that is copied into this helper.
///
/// Returns an error if `element` is not in a column that was passed to
/// [`ConstraintSystem::enable_equality`] during circuit configuration.
/// [`ConstraintSystemBuilder::enable_equality`] during circuit configuration.
pub fn copy_check(
&self,
mut layouter: impl Layouter<F>,
@ -393,7 +393,7 @@ mod tests {
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
dev::{FailureLocation, MockProver, VerifyFailure},
plonk::{Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystemBuilder, Error},
};
use pasta_curves::pallas;
@ -415,7 +415,7 @@ mod tests {
*self
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
let running_sum = meta.advice_column();
let table_idx = meta.lookup_table_column();
let constants = meta.fixed_column();
@ -514,7 +514,7 @@ mod tests {
}
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
let running_sum = meta.advice_column();
let table_idx = meta.lookup_table_column();
let constants = meta.fixed_column();

2
halo2_proofs/benches/dev_lookup.rs
View File

@ -33,7 +33,7 @@ fn criterion_benchmark(c: &mut Criterion) {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<F>) -> MyConfig {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> MyConfig {
let config = MyConfig {
selector: meta.complex_selector(),
table: meta.lookup_table_column(),

2
halo2_proofs/benches/plonk.rs
View File

@ -179,7 +179,7 @@ fn criterion_benchmark(c: &mut Criterion) {
}
}
fn configure(meta: &mut ConstraintSystem<F>) -> PlonkConfig {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> PlonkConfig {
meta.set_minimum_degree(5);
let a = meta.advice_column();

6
halo2_proofs/examples/circuit-layout.rs
View File

@ -2,7 +2,9 @@ use ff::Field;
use halo2_proofs::{
circuit::{Cell, Layouter, Region, SimpleFloorPlanner, Value},
pasta::Fp,
plonk::{Advice, Assigned, Circuit, Column, ConstraintSystem, Error, Fixed, TableColumn},
plonk::{
Advice, Assigned, Circuit, Column, ConstraintSystemBuilder, Error, Fixed, TableColumn,
},
poly::Rotation,
};
use rand_core::OsRng;
@ -170,7 +172,7 @@ impl<F: Field> Circuit<F> for MyCircuit<F> {
}
#[allow(clippy::many_single_char_names)]
fn configure(meta: &mut ConstraintSystem<F>) -> PlonkConfig {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> PlonkConfig {
let e = meta.advice_column();
let a = meta.advice_column();
let b = meta.advice_column();

6
halo2_proofs/examples/simple-example.rs
View File

@ -3,7 +3,7 @@ use std::marker::PhantomData;
use group::ff::Field;
use halo2_proofs::{
circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
plonk::{Advice, Circuit, Column, ConstraintSystem, Error, Fixed, Instance, Selector},
plonk::{Advice, Circuit, Column, ConstraintSystemBuilder, Error, Fixed, Instance, Selector},
poly::Rotation,
};
@ -74,7 +74,7 @@ impl<F: Field> FieldChip<F> {
}
fn configure(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
advice: [Column<Advice>; 2],
instance: Column<Instance>,
constant: Column<Fixed>,
@ -253,7 +253,7 @@ impl<F: Field> Circuit<F> for MyCircuit<F> {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
// We create the two advice columns that FieldChip uses for I/O.
let advice = [meta.advice_column(), meta.advice_column()];

10
halo2_proofs/examples/two-chip.rs
View File

@ -3,7 +3,7 @@ use std::marker::PhantomData;
use group::ff::Field;
use halo2_proofs::{
circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
plonk::{Advice, Circuit, Column, ConstraintSystem, Error, Instance, Selector},
plonk::{Advice, Circuit, Column, ConstraintSystemBuilder, Error, Instance, Selector},
poly::Rotation,
};
@ -153,7 +153,7 @@ impl<F: Field> AddChip<F> {
}
fn configure(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
advice: [Column<Advice>; 2],
) -> <Self as Chip<F>>::Config {
let s_add = meta.selector();
@ -255,7 +255,7 @@ impl<F: Field> MulChip<F> {
}
fn configure(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
advice: [Column<Advice>; 2],
) -> <Self as Chip<F>>::Config {
for column in &advice {
@ -376,7 +376,7 @@ impl<F: Field> FieldChip<F> {
}
fn configure(
meta: &mut ConstraintSystem<F>,
meta: &mut ConstraintSystemBuilder<F>,
advice: [Column<Advice>; 2],
instance: Column<Instance>,
) -> <Self as Chip<F>>::Config {
@ -463,7 +463,7 @@ impl<F: Field> Circuit<F> for MyCircuit<F> {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
// We create the two advice columns that FieldChip uses for I/O.
let advice = [meta.advice_column(), meta.advice_column()];

4
halo2_proofs/src/circuit/floor_planner/single_pass.rs
View File

@ -384,7 +384,9 @@ mod tests {
MyCircuit {}
}
fn configure(meta: &mut crate::plonk::ConstraintSystem<vesta::Scalar>) -> Self::Config {
fn configure(
meta: &mut crate::plonk::ConstraintSystemBuilder<vesta::Scalar>,
) -> Self::Config {
meta.advice_column()
}

2
halo2_proofs/src/circuit/floor_planner/v1.rs
View File

@ -498,7 +498,7 @@ mod tests {
MyCircuit {}
}
fn configure(meta: &mut crate::plonk::ConstraintSystem<vesta::Scalar>) -> Self::Config {
fn configure(meta: &mut crate::plonk::ConstraintSystemBuilder<vesta::Scalar>) -> Self::Config {
meta.advice_column()
}

10
halo2_proofs/src/circuit/table_layouter.rs
View File

@ -156,7 +156,7 @@ mod tests {
use crate::{
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
plonk::{Circuit, ConstraintSystem},
plonk::{Circuit, ConstraintSystemBuilder},
poly::Rotation,
};
@ -182,7 +182,7 @@ mod tests {
Self
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Self::Config {
let a = meta.advice_column();
let table = meta.lookup_table_column();
@ -240,7 +240,7 @@ mod tests {
Self
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Self::Config {
let a = meta.advice_column();
let table = meta.lookup_table_column();
@ -304,7 +304,7 @@ mod tests {
Self
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Self::Config {
let a = meta.advice_column();
let table = meta.lookup_table_column();
@ -369,7 +369,7 @@ mod tests {
Self
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Self::Config {
let a = meta.advice_column();
let table = (meta.lookup_table_column(), meta.lookup_table_column());
meta.lookup(|cells| {

61
halo2_proofs/src/dev.rs
View File

@ -11,8 +11,8 @@ use crate::plonk::Assigned;
use crate::{
circuit,
plonk::{
permutation, Advice, Any, Assignment, Circuit, Column, ConstraintSystem, Error, Expression,
Fixed, FloorPlanner, Instance, Selector,
permutation, Advice, Any, Assignment, Circuit, Column, ConstraintSystemBuilder, Error,
Expression, Fixed, FloorPlanner, Instance, Selector,
},
};
@ -198,7 +198,7 @@ impl<F: Field> Mul<F> for Value<F> {
/// Self::default()
/// }
///
/// fn configure(meta: &mut ConstraintSystem<F>) -> MyConfig {
/// fn configure(meta: &mut ConstraintSystemBuilder<F>) -> MyConfig {
/// let a = meta.advice_column();
/// let b = meta.advice_column();
/// let c = meta.advice_column();
@ -272,7 +272,7 @@ impl<F: Field> Mul<F> for Value<F> {
pub struct MockProver<F: Field> {
k: u32,
n: u32,
cs: ConstraintSystem<F>,
cs: ConstraintSystemBuilder<F>,
/// The regions in the circuit.
regions: Vec<Region>,
@ -489,7 +489,7 @@ impl<F: Field + Ord> MockProver<F> {
) -> Result<Self, Error> {
let n = 1 << k;
let mut cs = ConstraintSystem::default();
let mut cs = ConstraintSystemBuilder::default();
let config = ConcreteCircuit::configure(&mut cs);
let cs = cs;
@ -497,7 +497,7 @@ impl<F: Field + Ord> MockProver<F> {
return Err(Error::not_enough_rows_available(k));
}
if instance.len() != cs.num_instance_columns {
if instance.len() != cs.cs.num_instance_columns {
return Err(Error::InvalidInstances);
}
@ -518,8 +518,8 @@ impl<F: Field + Ord> MockProver<F> {
.collect::<Result<Vec<_>, _>>()?;
// Fixed columns contain no blinding factors.
let fixed = vec![vec![CellValue::Unassigned; n]; cs.num_fixed_columns];
let selectors = vec![vec![false; n]; cs.num_selectors];
let fixed = vec![vec![CellValue::Unassigned; n]; cs.cs.num_fixed_columns];
let selectors = vec![vec![false; n]; cs.cs.num_selectors];
// Advice columns contain blinding factors.
let blinding_factors = cs.blinding_factors();
let usable_rows = n - (blinding_factors + 1);
@ -532,10 +532,10 @@ impl<F: Field + Ord> MockProver<F> {
}
column
};
cs.num_advice_columns
cs.cs.num_advice_columns
];
let permutation = permutation::keygen::Assembly::new(n, &cs.permutation);
let constants = cs.constants.clone();
let permutation = permutation::keygen::Assembly::new(n, &cs.cs.permutation);
let constants = cs.cs.constants.clone();
let mut prover = MockProver {
k,
@ -577,6 +577,7 @@ impl<F: Field + Ord> MockProver<F> {
r.enabled_selectors.iter().flat_map(move |(selector, at)| {
// Find the gates enabled by this selector
self.cs
.cs
.gates
.iter()
// Assume that if a queried selector is enabled, the user wants to use the
@ -638,6 +639,7 @@ impl<F: Field + Ord> MockProver<F> {
// Check that all gates are satisfied for all rows.
let gate_errors =
self.cs
.cs
.gates
.iter()
.enumerate()
@ -648,12 +650,12 @@ impl<F: Field + Ord> MockProver<F> {
move |(poly_index, poly)| match poly.evaluate(
&|scalar| Value::Real(scalar),
&|_| panic!("virtual selectors are removed during optimization"),
&util::load(n, row, &self.cs.fixed_queries, &self.fixed),
&util::load(n, row, &self.cs.advice_queries, &self.advice),
&util::load(n, row, &self.cs.cs.fixed_queries, &self.fixed),
&util::load(n, row, &self.cs.cs.advice_queries, &self.advice),
&util::load_instance(
n,
row,
&self.cs.instance_queries,
&self.cs.cs.instance_queries,
&self.instance,
),
&|a| -a,
@ -670,7 +672,7 @@ impl<F: Field + Ord> MockProver<F> {
)
.into(),
location: FailureLocation::find_expressions(
&self.cs,
&self.cs.cs,
&self.regions,
(row - n) as usize,
Some(poly).into_iter(),
@ -678,12 +680,17 @@ impl<F: Field + Ord> MockProver<F> {
cell_values: util::cell_values(
gate,
poly,
&util::load(n, row, &self.cs.fixed_queries, &self.fixed),
&util::load(n, row, &self.cs.advice_queries, &self.advice),
&util::load(n, row, &self.cs.cs.fixed_queries, &self.fixed),
&util::load(
n,
row,
&self.cs.cs.advice_queries,
&self.advice,
),
&util::load_instance(
n,
row,
&self.cs.instance_queries,
&self.cs.cs.instance_queries,
&self.instance,
),
),
@ -704,6 +711,7 @@ impl<F: Field + Ord> MockProver<F> {
// Check that all lookups exist in their respective tables.
let lookup_errors =
self.cs
.cs
.lookups
.iter()
.enumerate()
@ -713,7 +721,7 @@ impl<F: Field + Ord> MockProver<F> {
&|scalar| Value::Real(scalar),
&|_| panic!("virtual selectors are removed during optimization"),
&|query| {
let query = self.cs.fixed_queries[query.index];
let query = self.cs.cs.fixed_queries[query.index];
let column_index = query.0.index();
let rotation = query.1 .0;
self.fixed[column_index]
@ -721,7 +729,7 @@ impl<F: Field + Ord> MockProver<F> {
.into()
},
&|query| {
let query = self.cs.advice_queries[query.index];
let query = self.cs.cs.advice_queries[query.index];
let column_index = query.0.index();
let rotation = query.1 .0;
self.advice[column_index]
@ -729,7 +737,7 @@ impl<F: Field + Ord> MockProver<F> {
.into()
},
&|query| {
let query = self.cs.instance_queries[query.index];
let query = self.cs.cs.instance_queries[query.index];
let column_index = query.0.index();
let rotation = query.1 .0;
Value::Real(
@ -814,7 +822,7 @@ impl<F: Field + Ord> MockProver<F> {
Some(VerifyFailure::Lookup {
lookup_index,
location: FailureLocation::find_expressions(
&self.cs,
&self.cs.cs,
&self.regions,
*input_row,
lookup.input_expressions.iter(),
@ -832,6 +840,7 @@ impl<F: Field + Ord> MockProver<F> {
// Original values of columns involved in the permutation.
let original = |column, row| {
self.cs
.cs
.permutation
.get_columns()
.get(column)
@ -860,7 +869,7 @@ impl<F: Field + Ord> MockProver<F> {
if original_cell == permuted_cell {
None
} else {
let columns = self.cs.permutation.get_columns();
let columns = self.cs.cs.permutation.get_columns();
let column = columns.get(column).unwrap();
Some(VerifyFailure::Permutation {
column: (*column).into(),
@ -927,7 +936,7 @@ mod tests {
use crate::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{
Advice, Any, Circuit, Column, ConstraintSystem, Error, Expression, Selector,
Advice, Any, Circuit, Column, ConstraintSystemBuilder, Error, Expression, Selector,
TableColumn,
},
poly::Rotation,
@ -949,7 +958,7 @@ mod tests {
type Config = FaultyCircuitConfig;
type FloorPlanner = SimpleFloorPlanner;
fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Self::Config {
let a = meta.advice_column();
let b = meta.advice_column();
let q = meta.selector();
@ -1023,7 +1032,7 @@ mod tests {
type Config = FaultyCircuitConfig;
type FloorPlanner = SimpleFloorPlanner;
fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<Fp>) -> Self::Config {
let a = meta.advice_column();
let q = meta.complex_selector();
let table = meta.lookup_table_column();

49
halo2_proofs/src/dev/cost.rs
View File

@ -14,7 +14,7 @@ use group::prime::PrimeGroup;
use crate::{
circuit::{layouter::RegionColumn, Value},
plonk::{
Advice, Any, Assigned, Assignment, Circuit, Column, ConstraintSystem, Error, Fixed,
Advice, Any, Assigned, Assignment, Circuit, Column, ConstraintSystemBuilder, Error, Fixed,
FloorPlanner, Instance, Selector,
},
poly::Rotation,
@ -260,14 +260,14 @@ impl<G: PrimeGroup, ConcreteCircuit: Circuit<G::Scalar>> CircuitCost<G, Concrete
/// Panics if `k` is not large enough for the circuit.
pub fn measure(k: u32, circuit: &ConcreteCircuit) -> Self {
// Collect the layout details.
let mut cs = ConstraintSystem::default();
let mut cs = ConstraintSystemBuilder::default();
let config = ConcreteCircuit::configure(&mut cs);
let mut layout = Layout::new(k, 1 << k, cs.num_selectors);
let mut layout = Layout::new(k, 1 << k, cs.cs.num_selectors);
ConcreteCircuit::FloorPlanner::synthesize(
&mut layout,
circuit,
config,
cs.constants.clone(),
cs.cs.constants.clone(),
)
.unwrap();
let (cs, _) = cs.compress_selectors(layout.selectors);
@ -278,14 +278,21 @@ impl<G: PrimeGroup, ConcreteCircuit: Circuit<G::Scalar>> CircuitCost<G, Concrete
let mut column_queries: HashMap<Column<Any>, HashSet<i32>> = HashMap::new();
for (c, r) in iter::empty()
.chain(
cs.advice_queries
cs.cs
.advice_queries
.iter()
.map(|(c, r)| (Column::<Any>::from(*c), *r)),
)
.chain(cs.instance_queries.iter().map(|(c, r)| ((*c).into(), *r)))
.chain(cs.fixed_queries.iter().map(|(c, r)| ((*c).into(), *r)))
.chain(
cs.permutation
cs.cs
.instance_queries
.iter()
.map(|(c, r)| ((*c).into(), *r)),
)
.chain(cs.cs.fixed_queries.iter().map(|(c, r)| ((*c).into(), *r)))
.chain(
cs.cs
.permutation
.get_columns()
.into_iter()
.map(|c| (c, Rotation::cur())),
@ -309,7 +316,7 @@ impl<G: PrimeGroup, ConcreteCircuit: Circuit<G::Scalar>> CircuitCost<G, Concrete
// Include permutation polynomials in point sets.
point_sets.insert(vec![0, 1]); // permutation_product_poly
let max_deg = cs.degree();
let permutation_cols = cs.permutation.get_columns().len();
let permutation_cols = cs.cs.permutation.get_columns().len();
if permutation_cols > max_deg - 2 {
// permutation_product_poly for chaining chunks.
point_sets.insert(vec![-((cs.blinding_factors() + 1) as i32), 0, 1]);
@ -318,23 +325,23 @@ impl<G: PrimeGroup, ConcreteCircuit: Circuit<G::Scalar>> CircuitCost<G, Concrete
CircuitCost {
k,
max_deg,
advice_columns: cs.num_advice_columns,
instance_queries: cs.instance_queries.len(),
advice_queries: cs.advice_queries.len(),
fixed_queries: cs.fixed_queries.len(),
lookups: cs.lookups.len(),
advice_columns: cs.cs.num_advice_columns,
instance_queries: cs.cs.instance_queries.len(),
advice_queries: cs.cs.advice_queries.len(),
fixed_queries: cs.cs.fixed_queries.len(),
lookups: cs.cs.lookups.len(),
permutation_cols,
point_sets: point_sets.len(),
_marker: PhantomData::default(),
max_rows: layout.total_rows,
max_advice_rows: layout.total_advice_rows,
max_fixed_rows: layout.total_fixed_rows,
num_advice_columns: cs.num_advice_columns,
num_fixed_columns: cs.num_fixed_columns,
num_instance_columns: cs.num_instance_columns,
num_total_columns: cs.num_instance_columns
+ cs.num_advice_columns
+ cs.num_fixed_columns,
num_advice_columns: cs.cs.num_advice_columns,
num_fixed_columns: cs.cs.num_fixed_columns,
num_instance_columns: cs.cs.num_instance_columns,
num_total_columns: cs.cs.num_instance_columns
+ cs.cs.num_advice_columns
+ cs.cs.num_fixed_columns,
}
}
@ -531,7 +538,7 @@ mod tests {
Self
}
fn configure(_meta: &mut ConstraintSystem<Fp>) -> Self::Config {}
fn configure(_meta: &mut ConstraintSystemBuilder<Fp>) -> Self::Config {}
fn synthesize(
&self,

19
halo2_proofs/src/dev/failure.rs
View File

@ -400,7 +400,7 @@ fn render_lookup<F: Field>(
) {
let n = prover.n as i32;
let cs = &prover.cs;
let lookup = &cs.lookups[lookup_index];
let lookup = &cs.cs.lookups[lookup_index];
// Get the absolute row on which the lookup's inputs are being queried, so we can
// fetch the input values.
@ -469,15 +469,15 @@ fn render_lookup<F: Field>(
&|_| panic!("virtual selectors are removed during optimization"),
&cell_value(
Any::Fixed,
&util::load(n, row, &cs.fixed_queries, &prover.fixed),
&util::load(n, row, &cs.cs.fixed_queries, &prover.fixed),
),
&cell_value(
Any::Advice,
&util::load(n, row, &cs.advice_queries, &prover.advice),
&util::load(n, row, &cs.cs.advice_queries, &prover.advice),
),
&cell_value(
Any::Instance,
&util::load_instance(n, row, &cs.instance_queries, &prover.instance),
&util::load_instance(n, row, &cs.cs.instance_queries, &prover.instance),
),
&|a| a,
&|mut a, mut b| {
@ -541,7 +541,7 @@ impl VerifyFailure {
column,
offset,
} => render_cell_not_assigned(
&prover.cs.gates,
&prover.cs.cs.gates,
gate,
region,
*gate_offset,
@ -552,9 +552,12 @@ impl VerifyFailure {
constraint,
location,
cell_values,
} => {
render_constraint_not_satisfied(&prover.cs.gates, constraint, location, cell_values)
}
} => render_constraint_not_satisfied(
&prover.cs.cs.gates,
constraint,
location,
cell_values,
),
Self::Lookup {
lookup_index,
location,

8
halo2_proofs/src/dev/gates.rs
View File

@ -7,7 +7,7 @@ use ff::PrimeField;
use crate::{
dev::util,
plonk::{Circuit, ConstraintSystem},
plonk::{Circuit, ConstraintSystemBuilder},
};
#[derive(Debug)]
@ -51,7 +51,7 @@ struct Gate {
/// Self::default()
/// }
///
/// fn configure(meta: &mut ConstraintSystem<F>) -> MyConfig {
/// fn configure(meta: &mut ConstraintSystemBuilder<F>) -> MyConfig {
/// let a = meta.advice_column();
/// let b = meta.advice_column();
/// let c = meta.advice_column();
@ -102,10 +102,11 @@ impl CircuitGates {
/// Collects the gates from within the circuit.
pub fn collect<F: PrimeField, C: Circuit<F>>() -> Self {
// Collect the graph details.
let mut cs = ConstraintSystem::default();
let mut cs = ConstraintSystemBuilder::default();
let _ = C::configure(&mut cs);
let gates = cs
.cs
.gates
.iter()
.map(|gate| Gate {
@ -185,6 +186,7 @@ impl CircuitGates {
.collect();
let (total_negations, total_additions, total_multiplications) = cs
.cs
.gates
.iter()
.flat_map(|gate| {

6
halo2_proofs/src/dev/graph.rs
View File

@ -4,7 +4,7 @@ use tabbycat::{AttrList, Edge, GraphBuilder, GraphType, Identity, StmtList};
use crate::{
circuit::Value,
plonk::{
Advice, Any, Assigned, Assignment, Circuit, Column, ConstraintSystem, Error, Fixed,
Advice, Any, Assigned, Assignment, Circuit, Column, ConstraintSystemBuilder, Error, Fixed,
FloorPlanner, Instance, Selector,
},
};
@ -21,10 +21,10 @@ pub fn circuit_dot_graph<F: Field, ConcreteCircuit: Circuit<F>>(
circuit: &ConcreteCircuit,
) -> String {
// Collect the graph details.
let mut cs = ConstraintSystem::default();
let mut cs = ConstraintSystemBuilder::default();
let config = ConcreteCircuit::configure(&mut cs);
let mut graph = Graph::default();
ConcreteCircuit::FloorPlanner::synthesize(&mut graph, circuit, config, cs.constants).unwrap();
ConcreteCircuit::FloorPlanner::synthesize(&mut graph, circuit, config, cs.cs.constants).unwrap();
// Construct the node labels. We need to store these, because tabbycat operates on
// string references, and we need those references to live long enough.

32
halo2_proofs/src/dev/graph/layout.rs
View File

@ -9,7 +9,7 @@ use std::ops::Range;
use crate::{
circuit::layouter::RegionColumn,
dev::cost::Layout,
plonk::{Any, Circuit, Column, ConstraintSystem, FloorPlanner},
plonk::{Any, Circuit, Column, ConstraintSystemBuilder, FloorPlanner},
};
/// Graphical renderer for circuit layouts.
@ -93,23 +93,24 @@ impl CircuitLayout {
let n = 1 << k;
// Collect the layout details.
let mut cs = ConstraintSystem::default();
let mut cs = ConstraintSystemBuilder::default();
let config = ConcreteCircuit::configure(&mut cs);
let mut layout = Layout::new(k, n, cs.num_selectors);
let mut layout = Layout::new(k, n, cs.cs.num_selectors);
ConcreteCircuit::FloorPlanner::synthesize(
&mut layout,
circuit,
config,
cs.constants.clone(),
cs.cs.constants.clone(),
)
.unwrap();
let (cs, selector_polys) = cs.compress_selectors(layout.selectors);
let non_selector_fixed_columns = cs.num_fixed_columns - selector_polys.len();
let non_selector_fixed_columns = cs.cs.num_fixed_columns - selector_polys.len();
// Figure out what order to render the columns in.
// TODO: For now, just render them in the order they were configured.
let total_columns = cs.num_instance_columns + cs.num_advice_columns + cs.num_fixed_columns;
let column_index = |cs: &ConstraintSystem<F>, column: RegionColumn| {
let total_columns =
cs.cs.num_instance_columns + cs.cs.num_advice_columns + cs.cs.num_fixed_columns;
let column_index = |cs: &ConstraintSystemBuilder<F>, column: RegionColumn| {
let column: Column<Any> = match column {
RegionColumn::Column(col) => col,
RegionColumn::Selector(selector) => cs.selector_map[selector.0].into(),
@ -117,8 +118,8 @@ impl CircuitLayout {
column.index()
+ match column.column_type() {
Any::Instance => 0,
Any::Advice => cs.num_instance_columns,
Any::Fixed => cs.num_instance_columns + cs.num_advice_columns,
Any::Advice => cs.cs.num_instance_columns,
Any::Fixed => cs.cs.num_instance_columns + cs.cs.num_advice_columns,
}
};
@ -140,14 +141,17 @@ impl CircuitLayout {
))?;
root.draw(&Rectangle::new(
[
(cs.num_instance_columns, 0),
(cs.num_instance_columns + cs.num_advice_columns, view_bottom),
(cs.cs.num_instance_columns, 0),
(
cs.cs.num_instance_columns + cs.cs.num_advice_columns,
view_bottom,
),
],
ShapeStyle::from(&RED.mix(0.2)).filled(),
))?;
root.draw(&Rectangle::new(
[
(cs.num_instance_columns + cs.num_advice_columns, 0),
(cs.cs.num_instance_columns + cs.cs.num_advice_columns, 0),
(total_columns, view_bottom),
],
ShapeStyle::from(&BLUE.mix(0.2)).filled(),
@ -156,8 +160,8 @@ impl CircuitLayout {
root.draw(&Rectangle::new(
[
(
cs.num_instance_columns
+ cs.num_advice_columns
cs.cs.num_instance_columns
+ cs.cs.num_advice_columns
+ non_selector_fixed_columns,
0,
),

6
halo2_proofs/src/dev/tfp.rs
View File

@ -6,7 +6,7 @@ use tracing::{debug, debug_span, span::EnteredSpan};
use crate::{
circuit::{layouter::RegionLayouter, AssignedCell, Cell, Layouter, Region, Table, Value},
plonk::{
Advice, Any, Assigned, Assignment, Circuit, Column, ConstraintSystem, Error, Fixed,
Advice, Any, Assigned, Assignment, Circuit, Column, ConstraintSystemBuilder, Error, Fixed,
FloorPlanner, Instance, Selector,
},
};
@ -50,7 +50,7 @@ use crate::{
/// Self { some_witness: Value::unknown() }
/// }
///
/// fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
/// fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
/// // ..
/// # todo!()
/// }
@ -126,7 +126,7 @@ impl<'c, F: Field, C: Circuit<F>> Circuit<F> for TracingCircuit<'c, F, C> {
Self::owned(self.inner_ref().without_witnesses())
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {
let _span = debug_span!("configure").entered();
C::configure(meta)
}

8
halo2_proofs/src/plonk.rs
View File

@ -45,6 +45,8 @@ pub struct VerifyingKey<C: CurveAffine> {
cs: ConstraintSystem<C::Scalar>,
/// Cached maximum degree of `cs` (which doesn't change after construction).
cs_degree: usize,
/// Cached number of blinding factors (which doesn't change after construction).
num_blinding_factors: usize,
/// The representative of this `VerifyingKey` in transcripts.
transcript_repr: C::Scalar,
}
@ -57,17 +59,19 @@ where
domain: EvaluationDomain<C::Scalar>,
fixed_commitments: Vec<C>,
permutation: permutation::VerifyingKey<C>,
cs: ConstraintSystem<C::Scalar>,
cs: ConstraintSystemBuilder<C::Scalar>,
) -> Self {
// Compute cached values.
let cs_degree = cs.degree();
let num_blinding_factors = cs.blinding_factors();
let mut vk = Self {
domain,
fixed_commitments,
permutation,
cs,
cs: cs.cs,
cs_degree,
num_blinding_factors,
// Temporary, this is not pinned.
transcript_repr: C::Scalar::ZERO,
};

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

@ -305,7 +305,7 @@ pub struct InstanceQuery {
///
/// A lookup table can be loaded into this column via [`Layouter::assign_table`]. Columns
/// can currently only contain a single table, but they may be used in multiple lookup
/// arguments via [`ConstraintSystem::lookup`].
/// arguments via [`ConstraintSystemBuilder::lookup`].
///
/// Lookup table columns are always "encumbered" by the lookup arguments they are used in;
/// they cannot simultaneously be used as general fixed columns.
@ -329,7 +329,7 @@ impl TableColumn {
}
/// Enable equality on this TableColumn.
pub fn enable_equality<F: Field>(&self, meta: &mut ConstraintSystem<F>) {
pub fn enable_equality<F: Field>(&self, meta: &mut ConstraintSystemBuilder<F>) {
meta.enable_equality(self.inner)
}
}
@ -476,7 +476,7 @@ pub trait Circuit<F: Field> {
/// The circuit is given an opportunity to describe the exact gate
/// arrangement, column arrangement, etc.
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config;
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> Self::Config;
/// Given the provided `cs`, synthesize the circuit. The concrete type of
/// the caller will be different depending on the context, and they may or
@ -928,6 +928,22 @@ impl<F: Field> Gate<F> {
}
}
/// A builder type for a [`ConstraintSystem`].
#[derive(Debug, Clone, Default)]
pub struct ConstraintSystemBuilder<F: Field> {
pub(crate) cs: ConstraintSystem<F>,
/// This is a cached vector that maps virtual selectors to the concrete
/// fixed column that they were compressed into. This is just used by dev
/// tooling right now.
pub(crate) selector_map: Vec<Column<Fixed>>,
// Contains an integer for each advice column
// identifying how many distinct queries it has
// so far; should be same length as num_advice_columns.
num_advice_queries: Vec<usize>,
}
/// This is a description of the circuit environment, such as the gate, column and
/// permutation arrangements.
#[derive(Debug, Clone)]
@ -937,17 +953,8 @@ pub struct ConstraintSystem<F: Field> {
pub(crate) num_instance_columns: usize,
pub(crate) num_selectors: usize,
/// This is a cached vector that maps virtual selectors to the concrete
/// 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) advice_queries: Vec<(Column<Advice>, Rotation)>,
// Contains an integer for each advice column
// identifying how many distinct queries it has
// so far; should be same length as num_advice_columns.
num_advice_queries: Vec<usize>,
pub(crate) instance_queries: Vec<(Column<Instance>, Rotation)>,
pub(crate) fixed_queries: Vec<(Column<Fixed>, Rotation)>,
@ -1000,11 +1007,9 @@ impl<F: Field> Default for ConstraintSystem<F> {
num_advice_columns: 0,
num_instance_columns: 0,
num_selectors: 0,
selector_map: vec![],
gates: vec![],
fixed_queries: Vec::new(),
advice_queries: Vec::new(),
num_advice_queries: Vec::new(),
instance_queries: Vec::new(),
permutation: permutation::Argument::new(),
lookups: Vec::new(),
@ -1034,15 +1039,17 @@ impl<F: Field> ConstraintSystem<F> {
minimum_degree: &self.minimum_degree,
}
}
}
impl<F: Field> ConstraintSystemBuilder<F> {
/// Enables this fixed column to be used for global constant assignments.
///
/// # Side-effects
///
/// The column will be equality-enabled.
pub fn enable_constant(&mut self, column: Column<Fixed>) {
if !self.constants.contains(&column) {
self.constants.push(column);
if !self.cs.constants.contains(&column) {
self.cs.constants.push(column);
self.enable_equality(column);
}
}
@ -1051,7 +1058,7 @@ impl<F: Field> ConstraintSystem<F> {
pub fn enable_equality<C: Into<Column<Any>>>(&mut self, column: C) {
let column = column.into();
self.query_any_index(column, Rotation::cur());
self.permutation.add_column(column);
self.cs.permutation.add_column(column);
}
/// Add a lookup argument for some input expressions and table columns.
@ -1076,39 +1083,39 @@ impl<F: Field> ConstraintSystem<F> {
})
.collect();
let index = self.lookups.len();
let index = self.cs.lookups.len();
self.lookups.push(lookup::Argument::new(table_map));
self.cs.lookups.push(lookup::Argument::new(table_map));
index
}
fn query_fixed_index(&mut self, column: Column<Fixed>) -> usize {
// Return existing query, if it exists
for (index, fixed_query) in self.fixed_queries.iter().enumerate() {
for (index, fixed_query) in self.cs.fixed_queries.iter().enumerate() {
if fixed_query == &(column, Rotation::cur()) {
return index;
}
}
// Make a new query
let index = self.fixed_queries.len();
self.fixed_queries.push((column, Rotation::cur()));
let index = self.cs.fixed_queries.len();
self.cs.fixed_queries.push((column, Rotation::cur()));
index
}
pub(crate) fn query_advice_index(&mut self, column: Column<Advice>, at: Rotation) -> usize {
// Return existing query, if it exists
for (index, advice_query) in self.advice_queries.iter().enumerate() {
for (index, advice_query) in self.cs.advice_queries.iter().enumerate() {
if advice_query == &(column, at) {
return index;
}
}
// Make a new query
let index = self.advice_queries.len();
self.advice_queries.push((column, at));
let index = self.cs.advice_queries.len();
self.cs.advice_queries.push((column, at));
self.num_advice_queries[column.index] += 1;
index
@ -1116,15 +1123,15 @@ impl<F: Field> ConstraintSystem<F> {
fn query_instance_index(&mut self, column: Column<Instance>, at: Rotation) -> usize {
// Return existing query, if it exists
for (index, instance_query) in self.instance_queries.iter().enumerate() {
for (index, instance_query) in self.cs.instance_queries.iter().enumerate() {
if instance_query == &(column, at) {
return index;
}
}
// Make a new query
let index = self.instance_queries.len();
self.instance_queries.push((column, at));
let index = self.cs.instance_queries.len();
self.cs.instance_queries.push((column, at));
index
}
@ -1138,7 +1145,9 @@ impl<F: Field> ConstraintSystem<F> {
}
}
}
}
impl<F: Field> ConstraintSystem<F> {
pub(crate) fn get_advice_query_index(&self, column: Column<Advice>, at: Rotation) -> usize {
for (index, advice_query) in self.advice_queries.iter().enumerate() {
if advice_query == &(column, at) {
@ -1183,12 +1192,14 @@ impl<F: Field> ConstraintSystem<F> {
),
}
}
}
impl<F: Field> ConstraintSystemBuilder<F> {
/// Sets the minimum degree required by the circuit, which can be set to a
/// larger amount than actually needed. This can be used, for example, to
/// force the permutation argument to involve more columns in the same set.
pub fn set_minimum_degree(&mut self, degree: usize) {
self.minimum_degree = Some(degree);
self.cs.minimum_degree = Some(degree);
}
/// Creates a new gate.
@ -1218,7 +1229,7 @@ impl<F: Field> ConstraintSystem<F> {
"Gates must contain at least one constraint."
);
self.gates.push(Gate {
self.cs.gates.push(Gate {
name,
constraint_names,
polys,
@ -1237,14 +1248,14 @@ impl<F: Field> ConstraintSystem<F> {
pub(crate) fn compress_selectors(mut self, selectors: Vec<Vec<bool>>) -> (Self, Vec<Vec<F>>) {
// The number of provided selector assignments must be the number we
// counted for this constraint system.
assert_eq!(selectors.len(), self.num_selectors);
assert_eq!(selectors.len(), self.cs.num_selectors);
// Compute the maximal degree of every selector. We only consider the
// expressions in gates, as lookup arguments cannot support simple
// selectors. Selectors that are complex or do not appear in any gates
// will have degree zero.
let mut degrees = vec![0; selectors.len()];
for expr in self.gates.iter().flat_map(|gate| gate.polys.iter()) {
for expr in self.cs.gates.iter().flat_map(|gate| gate.polys.iter()) {
if let Some(selector) = expr.extract_simple_selector() {
degrees[selector.0] = max(degrees[selector.0], expr.degree());
}
@ -1324,13 +1335,18 @@ impl<F: Field> ConstraintSystem<F> {
}
// Substitute selectors for the real fixed columns in all gates
for expr in self.gates.iter_mut().flat_map(|gate| gate.polys.iter_mut()) {
for expr in self
.cs
.gates
.iter_mut()
.flat_map(|gate| gate.polys.iter_mut())
{
replace_selectors(expr, &selector_replacements, false);
}
// Substitute non-simple selectors for the real fixed columns in all
// lookup expressions
for expr in self.lookups.iter_mut().flat_map(|lookup| {
for expr in self.cs.lookups.iter_mut().flat_map(|lookup| {
lookup
.input_expressions
.iter_mut()
@ -1347,16 +1363,16 @@ impl<F: Field> ConstraintSystem<F> {
/// selectors. Also, simple selectors may not appear in lookup argument
/// inputs.
pub fn selector(&mut self) -> Selector {
let index = self.num_selectors;
self.num_selectors += 1;
let index = self.cs.num_selectors;
self.cs.num_selectors += 1;
Selector(index, true)
}
/// Allocate a new complex selector that can appear anywhere
/// within expressions.
pub fn complex_selector(&mut self) -> Selector {
let index = self.num_selectors;
self.num_selectors += 1;
let index = self.cs.num_selectors;
self.cs.num_selectors += 1;
Selector(index, false)
}
@ -1370,20 +1386,20 @@ impl<F: Field> ConstraintSystem<F> {
/// Allocate a new fixed column
pub fn fixed_column(&mut self) -> Column<Fixed> {
let tmp = Column {
index: self.num_fixed_columns,
index: self.cs.num_fixed_columns,
column_type: Fixed,
};
self.num_fixed_columns += 1;
self.cs.num_fixed_columns += 1;
tmp
}
/// Allocate a new advice column
pub fn advice_column(&mut self) -> Column<Advice> {
let tmp = Column {
index: self.num_advice_columns,
index: self.cs.num_advice_columns,
column_type: Advice,
};
self.num_advice_columns += 1;
self.cs.num_advice_columns += 1;
self.num_advice_queries.push(0);
tmp
}
@ -1391,10 +1407,10 @@ impl<F: Field> ConstraintSystem<F> {
/// Allocate a new instance column
pub fn instance_column(&mut self) -> Column<Instance> {
let tmp = Column {
index: self.num_instance_columns,
index: self.cs.num_instance_columns,
column_type: Instance,
};
self.num_instance_columns += 1;
self.cs.num_instance_columns += 1;
tmp
}
@ -1403,13 +1419,14 @@ impl<F: Field> ConstraintSystem<F> {
pub fn degree(&self) -> usize {
// The permutation argument will serve alongside the gates, so must be
// accounted for.
let mut degree = self.permutation.required_degree();
let mut degree = self.cs.permutation.required_degree();
// The lookup argument also serves alongside the gates and must be accounted
// for.
degree = std::cmp::max(
degree,
self.lookups
self.cs
.lookups
.iter()
.map(|l| l.required_degree())
.max()
@ -1420,14 +1437,15 @@ impl<F: Field> ConstraintSystem<F> {
// correct degree and that our extended domain is the right size.
degree = std::cmp::max(
degree,
self.gates
self.cs
.gates
.iter()
.flat_map(|gate| gate.polynomials().iter().map(|poly| poly.degree()))
.max()
.unwrap_or(0),
);
std::cmp::max(degree, self.minimum_degree.unwrap_or(1))
std::cmp::max(degree, self.cs.minimum_degree.unwrap_or(1))
}
/// Compute the number of blinding factors necessary to perfectly blind
@ -1476,13 +1494,13 @@ impl<F: Field> ConstraintSystem<F> {
/// table.
#[derive(Debug)]
pub struct VirtualCells<'a, F: Field> {
meta: &'a mut ConstraintSystem<F>,
meta: &'a mut ConstraintSystemBuilder<F>,
queried_selectors: Vec<Selector>,
queried_cells: Vec<VirtualCell>,
}
impl<'a, F: Field> VirtualCells<'a, F> {
fn new(meta: &'a mut ConstraintSystem<F>) -> Self {
fn new(meta: &'a mut ConstraintSystemBuilder<F>) -> Self {
VirtualCells {
meta,
queried_selectors: vec![],

4
halo2_proofs/src/plonk/error.rs
View File

@ -31,9 +31,9 @@ pub enum Error {
/// Instance provided exceeds number of available rows
InstanceTooLarge,
/// Circuit synthesis requires global constants, but circuit configuration did not
/// call [`ConstraintSystem::enable_constant`] on fixed columns with sufficient space.
/// call [`ConstraintSystemBuilder::enable_constant`] on fixed columns with sufficient space.
///
/// [`ConstraintSystem::enable_constant`]: crate::plonk::ConstraintSystem::enable_constant
/// [`ConstraintSystemBuilder::enable_constant`]: crate::plonk::ConstraintSystemBuilder::enable_constant
NotEnoughColumnsForConstants,
/// The instance sets up a copy constraint involving a column that has not been
/// included in the permutation.

36
halo2_proofs/src/plonk/keygen.rs
View File

@ -6,11 +6,9 @@ use ff::{Field, FromUniformBytes};
use group::Curve;
use super::{
circuit::{
Advice, Any, Assignment, Circuit, Column, ConstraintSystem, Fixed, FloorPlanner, Instance,
Selector,
},
permutation, Assigned, Error, LagrangeCoeff, Polynomial, ProvingKey, VerifyingKey,
circuit::{Advice, Any, Assignment, Circuit, Column, Fixed, FloorPlanner, Instance, Selector},
permutation, Assigned, ConstraintSystemBuilder, Error, LagrangeCoeff, Polynomial, ProvingKey,
VerifyingKey,
};
use crate::{
arithmetic::CurveAffine,
@ -26,14 +24,14 @@ pub(crate) fn create_domain<C, ConcreteCircuit>(
params: &Params<C>,
) -> (
EvaluationDomain<C::Scalar>,
ConstraintSystem<C::Scalar>,
ConstraintSystemBuilder<C::Scalar>,
ConcreteCircuit::Config,
)
where
C: CurveAffine,
ConcreteCircuit: Circuit<C::Scalar>,
{
let mut cs = ConstraintSystem::default();
let mut cs = ConstraintSystemBuilder::default();
let config = ConcreteCircuit::configure(&mut cs);
let degree = cs.degree();
@ -203,9 +201,9 @@ where
let mut assembly: Assembly<C::Scalar> = Assembly {
k: params.k,
fixed: vec![domain.empty_lagrange_assigned(); cs.num_fixed_columns],
permutation: permutation::keygen::Assembly::new(params.n as usize, &cs.permutation),
selectors: vec![vec![false; params.n as usize]; cs.num_selectors],
fixed: vec![domain.empty_lagrange_assigned(); cs.cs.num_fixed_columns],
permutation: permutation::keygen::Assembly::new(params.n as usize, &cs.cs.permutation),
selectors: vec![vec![false; params.n as usize]; cs.cs.num_selectors],
usable_rows: 0..params.n as usize - (cs.blinding_factors() + 1),
_marker: std::marker::PhantomData,
};
@ -215,7 +213,7 @@ where
&mut assembly,
circuit,
config,
cs.constants.clone(),
cs.cs.constants.clone(),
)?;
let mut fixed = batch_invert_assigned(assembly.fixed);
@ -226,9 +224,11 @@ where
.map(|poly| domain.lagrange_from_vec(poly)),
);
// This is post-optimization.
let permutation_vk = assembly
.permutation
.build_vk(params, &domain, &cs.permutation);
.build_vk(params, &domain, &cs.cs.permutation);
let fixed_commitments = fixed
.iter()
@ -253,7 +253,7 @@ where
C: CurveAffine,
ConcreteCircuit: Circuit<C::Scalar>,
{
let mut cs = ConstraintSystem::default();
let mut cs = ConstraintSystemBuilder::default();
let config = ConcreteCircuit::configure(&mut cs);
let cs = cs;
@ -264,9 +264,9 @@ where
let mut assembly: Assembly<C::Scalar> = Assembly {
k: params.k,
fixed: vec![vk.domain.empty_lagrange_assigned(); cs.num_fixed_columns],
permutation: permutation::keygen::Assembly::new(params.n as usize, &cs.permutation),
selectors: vec![vec![false; params.n as usize]; cs.num_selectors],
fixed: vec![vk.domain.empty_lagrange_assigned(); cs.cs.num_fixed_columns],
permutation: permutation::keygen::Assembly::new(params.n as usize, &cs.cs.permutation),
selectors: vec![vec![false; params.n as usize]; cs.cs.num_selectors],
usable_rows: 0..params.n as usize - (cs.blinding_factors() + 1),
_marker: std::marker::PhantomData,
};
@ -276,7 +276,7 @@ where
&mut assembly,
circuit,
config,
cs.constants.clone(),
cs.cs.constants.clone(),
)?;
let mut fixed = batch_invert_assigned(assembly.fixed);
@ -299,7 +299,7 @@ where
let permutation_pk = assembly
.permutation
.build_pk(params, &vk.domain, &cs.permutation);
.build_pk(params, &vk.domain, &cs.cs.permutation);
// Compute l_0(X)
// TODO: this can be done more efficiently

4
halo2_proofs/src/plonk/lookup/prover.rs
View File

@ -264,7 +264,7 @@ impl<C: CurveAffine, Ev: Copy + Send + Sync> Permuted<C, Ev> {
mut rng: R,
transcript: &mut T,
) -> Result<Committed<C, Ev>, Error> {
let blinding_factors = pk.vk.cs.blinding_factors();
let blinding_factors = pk.vk.num_blinding_factors;
// Goal is to compute the products of fractions
//
// Numerator: (\theta^{m-1} a_0(\omega^i) + \theta^{m-2} a_1(\omega^i) + ... + \theta a_{m-2}(\omega^i) + a_{m-1}(\omega^i) + \beta)
@ -568,7 +568,7 @@ fn permute_expression_pair<C: CurveAffine, R: RngCore>(
input_expression: &Polynomial<C::Scalar, LagrangeCoeff>,
table_expression: &Polynomial<C::Scalar, LagrangeCoeff>,
) -> Result<ExpressionPair<C::Scalar>, Error> {
let blinding_factors = pk.vk.cs.blinding_factors();
let blinding_factors = pk.vk.num_blinding_factors;
let usable_rows = params.n as usize - (blinding_factors + 1);
let mut permuted_input_expression: Vec<C::Scalar> = input_expression.to_vec();

8
halo2_proofs/src/plonk/permutation/prover.rs
View File

@ -72,7 +72,7 @@ impl Argument {
// 3 circuit for the permutation argument.
assert!(pk.vk.cs_degree >= 3);
let chunk_len = pk.vk.cs_degree - 2;
let blinding_factors = pk.vk.cs.blinding_factors();
let blinding_factors = pk.vk.num_blinding_factors;
// Each column gets its own delta power.
let mut deltaomega = C::Scalar::ONE;
@ -214,7 +214,7 @@ impl<C: CurveAffine, Ev: Copy + Send + Sync> Committed<C, Ev> {
impl Iterator<Item = poly::Ast<Ev, C::Scalar, ExtendedLagrangeCoeff>> + 'a,
) {
let chunk_len = pk.vk.cs_degree - 2;
let blinding_factors = pk.vk.cs.blinding_factors();
let blinding_factors = pk.vk.num_blinding_factors;
let last_rotation = Rotation(-((blinding_factors + 1) as i32));
let constructed = Constructed {
@ -346,7 +346,7 @@ impl<C: CurveAffine> Constructed<C> {
transcript: &mut T,
) -> Result<Evaluated<C>, Error> {
let domain = &pk.vk.domain;
let blinding_factors = pk.vk.cs.blinding_factors();
let blinding_factors = pk.vk.num_blinding_factors;
{
let mut sets = self.sets.iter();
@ -391,7 +391,7 @@ impl<C: CurveAffine> Evaluated<C> {
pk: &'a plonk::ProvingKey<C>,
x: ChallengeX<C>,
) -> impl Iterator<Item = ProverQuery<'a, C>> + Clone {
let blinding_factors = pk.vk.cs.blinding_factors();
let blinding_factors = pk.vk.num_blinding_factors;
let x_next = pk.vk.domain.rotate_omega(*x, Rotation::next());
let x_last = pk
.vk

2
halo2_proofs/src/plonk/permutation/verifier.rs
View File

@ -193,7 +193,7 @@ impl<C: CurveAffine> Evaluated<C> {
vk: &'r plonk::VerifyingKey<C>,
x: ChallengeX<C>,
) -> impl Iterator<Item = VerifierQuery<'r, 'params, C>> + Clone {
let blinding_factors = vk.cs.blinding_factors();
let blinding_factors = vk.num_blinding_factors;
let x_next = vk.domain.rotate_omega(*x, Rotation::next());
let x_last = vk
.domain

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

@ -5,17 +5,14 @@ use std::iter;
use std::ops::RangeTo;
use super::{
circuit::{
Advice, Any, Assignment, Circuit, Column, ConstraintSystem, Fixed, FloorPlanner, Instance,
Selector,
},
circuit::{Advice, Any, Assignment, Circuit, Column, Fixed, FloorPlanner, Instance, Selector},
lookup, permutation, vanishing, ChallengeBeta, ChallengeGamma, ChallengeTheta, ChallengeX,
ChallengeY, Error, ProvingKey,
};
use crate::{
arithmetic::{eval_polynomial, CurveAffine},
circuit::Value,
plonk::Assigned,
plonk::{Assigned, ConstraintSystemBuilder},
poly::{
self,
commitment::{Blind, Params},
@ -60,7 +57,7 @@ pub fn create_proof<
pk.vk.hash_into(transcript)?;
let domain = &pk.vk.domain;
let mut meta = ConstraintSystem::default();
let mut meta = ConstraintSystemBuilder::default();
let config = ConcreteCircuit::configure(&mut meta);
// Selector optimizations cannot be applied here; use the ConstraintSystem
@ -81,7 +78,7 @@ pub fn create_proof<
.map(|values| {
let mut poly = domain.empty_lagrange();
assert_eq!(poly.len(), params.n as usize);
if values.len() > (poly.len() - (meta.blinding_factors() + 1)) {
if values.len() > (poly.len() - (pk.vk.num_blinding_factors + 1)) {
return Err(Error::InstanceTooLarge);
}
for (poly, value) in poly.iter_mut().zip(values.iter()) {
@ -266,7 +263,7 @@ pub fn create_proof<
}
}
let unusable_rows_start = params.n as usize - (meta.blinding_factors() + 1);
let unusable_rows_start = params.n as usize - (pk.vk.num_blinding_factors + 1);
let mut witness = WitnessCollection {
k: params.k,
@ -746,7 +743,7 @@ fn test_create_proof() {
*self
}
fn configure(_meta: &mut ConstraintSystem<F>) -> Self::Config {}
fn configure(_meta: &mut ConstraintSystemBuilder<F>) -> Self::Config {}
fn synthesize(
&self,

4
halo2_proofs/src/plonk/verifier.rs
View File

@ -90,7 +90,7 @@ pub fn verify_proof<
instance
.iter()
.map(|instance| {
if instance.len() > params.n as usize - (vk.cs.blinding_factors() + 1) {
if instance.len() > params.n as usize - (vk.num_blinding_factors + 1) {
return Err(Error::InstanceTooLarge);
}
let mut poly = instance.to_vec();
@ -205,7 +205,7 @@ pub fn verify_proof<
// x^n
let xn = x.pow(&[params.n, 0, 0, 0]);
let blinding_factors = vk.cs.blinding_factors();
let blinding_factors = vk.num_blinding_factors;
let l_evals = vk
.domain
.l_i_range(*x, xn, (-((blinding_factors + 1) as i32))..=0);

5
halo2_proofs/tests/plonk_api.rs
View File

@ -9,7 +9,8 @@ use halo2_proofs::dev::MockProver;
use halo2_proofs::pasta::{Eq, EqAffine, Fp};
use halo2_proofs::plonk::{
create_proof, keygen_pk, keygen_vk, verify_proof, Advice, Assigned, BatchVerifier, Circuit,
Column, ConstraintSystem, Error, Fixed, SingleVerifier, TableColumn, VerificationStrategy,
Column, ConstraintSystemBuilder, Error, Fixed, SingleVerifier, TableColumn,
VerificationStrategy,
};
use halo2_proofs::poly::commitment::{Guard, MSM};
use halo2_proofs::poly::{commitment::Params, Rotation};
@ -272,7 +273,7 @@ fn plonk_api() {
}
}
fn configure(meta: &mut ConstraintSystem<F>) -> PlonkConfig {
fn configure(meta: &mut ConstraintSystemBuilder<F>) -> PlonkConfig {
let e = meta.advice_column();
let a = meta.advice_column();
let b = meta.advice_column();