logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-06 15:53:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use *_circuit suffix for gadgets

Browse Source
This commit is contained in:
wborgeaud 2022-05-17 11:04:35 +02:00
parent e10e103933
commit b606d99e07
47 changed files with 156 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
insertion/src/insertion_gate.rs
View File

@ -153,7 +153,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for InsertionGate<
}
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
plonky2/src/gates/arithmetic_base.rs
View File

@ -86,7 +86,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ArithmeticGate
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
plonky2/src/gates/arithmetic_extension.rs
View File

@ -93,7 +93,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ArithmeticExte
}
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

8
plonky2/src/gates/assert_le.rs
View File

@ -15,7 +15,7 @@ use crate::iop::target::Target;
use crate::iop::wire::Wire;
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_recursive};
use crate::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_circuit};
use crate::plonk::vars::{
EvaluationTargets, EvaluationVars, EvaluationVarsBase, EvaluationVarsBaseBatch,
EvaluationVarsBasePacked,
@ -168,7 +168,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for AssertLessThan
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,
@ -188,9 +188,9 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for AssertLessThan
let chunk_base = builder.constant(F::from_canonical_usize(1 << self.chunk_bits()));
let first_chunks_combined =
reduce_with_powers_ext_recursive(builder, &first_chunks, chunk_base);
reduce_with_powers_ext_circuit(builder, &first_chunks, chunk_base);
let second_chunks_combined =
reduce_with_powers_ext_recursive(builder, &second_chunks, chunk_base);
reduce_with_powers_ext_circuit(builder, &second_chunks, chunk_base);
constraints.push(builder.sub_extension(first_chunks_combined, first_input));
constraints.push(builder.sub_extension(second_chunks_combined, second_input));

6
plonky2/src/gates/base_sum.rs
View File

@ -14,7 +14,7 @@ use crate::iop::target::Target;
use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig;
use crate::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_recursive};
use crate::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_circuit};
use crate::plonk::vars::{
EvaluationTargets, EvaluationVars, EvaluationVarsBase, EvaluationVarsBaseBatch,
EvaluationVarsBasePacked,
@ -77,7 +77,7 @@ impl<F: RichField + Extendable<D>, const D: usize, const B: usize> Gate<F, D> fo
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,
@ -85,7 +85,7 @@ impl<F: RichField + Extendable<D>, const D: usize, const B: usize> Gate<F, D> fo
let base = builder.constant(F::from_canonical_usize(B));
let sum = vars.local_wires[Self::WIRE_SUM];
let limbs = vars.local_wires[self.limbs()].to_vec();
let computed_sum = reduce_with_powers_ext_recursive(builder, &limbs, base);
let computed_sum = reduce_with_powers_ext_circuit(builder, &limbs, base);
let mut constraints = vec![builder.sub_extension(computed_sum, sum)];
for limb in limbs {
constraints.push({

2
plonky2/src/gates/constant.rs
View File

@ -56,7 +56,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ConstantGate {
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
plonky2/src/gates/exponentiation.rs
View File

@ -120,7 +120,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for Exponentiation
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

10
plonky2/src/gates/gate.rs
View File

@ -75,7 +75,7 @@ pub trait Gate<F: RichField + Extendable<D>, const D: usize>: 'static + Send + S
res
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,
@ -132,7 +132,7 @@ pub trait Gate<F: RichField + Extendable<D>, const D: usize>: 'static + Send + S
}
/// Adds this gate's filtered constraints into the `combined_gate_constraints` buffer.
fn eval_filtered_recursively(
fn eval_filtered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
mut vars: EvaluationTargets<D>,
@ -142,7 +142,7 @@ pub trait Gate<F: RichField + Extendable<D>, const D: usize>: 'static + Send + S
num_selectors: usize,
combined_gate_constraints: &mut [ExtensionTarget<D>],
) {
let filter = compute_filter_recursively(
let filter = compute_filter_circuit(
builder,
gate_index,
group_range,
@ -150,7 +150,7 @@ pub trait Gate<F: RichField + Extendable<D>, const D: usize>: 'static + Send + S
num_selectors > 1,
);
vars.remove_prefix(num_selectors);
let my_constraints = self.eval_unfiltered_recursively(builder, vars);
let my_constraints = self.eval_unfiltered_circuit(builder, vars);
for (acc, c) in combined_gate_constraints.iter_mut().zip(my_constraints) {
*acc = builder.mul_add_extension(filter, c, *acc);
}
@ -258,7 +258,7 @@ fn compute_filter<K: Field>(
.product()
}
fn compute_filter_recursively<F: RichField + Extendable<D>, const D: usize>(
fn compute_filter_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
gate_index: usize,
group_range: Range<usize>,

2
plonky2/src/gates/gate_testing.rs
View File

@ -156,7 +156,7 @@ where
local_wires: &wires_t,
public_inputs_hash: &public_inputs_hash_t,
};
let evals_t = gate.eval_unfiltered_recursively(&mut builder, vars_t);
let evals_t = gate.eval_unfiltered_circuit(&mut builder, vars_t);
pw.set_extension_targets(&evals_t, &evals);
let data = builder.build::<C>();

6
plonky2/src/gates/interpolation.rs
View File

@ -64,7 +64,7 @@ impl<F: RichField + Extendable<D>, const D: usize> HighDegreeInterpolationGate<F
}
/// The domain of the points we're interpolating.
fn coset_ext_recursive(
fn coset_ext_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
shift: ExtensionTarget<D>,
@ -134,7 +134,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D>
yield_constr.many((evaluation_value - computed_evaluation_value).to_basefield_array());
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,
@ -146,7 +146,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D>
.collect();
let interpolant = PolynomialCoeffsExtAlgebraTarget(coeffs);
let coset = self.coset_ext_recursive(builder, vars.local_wires[self.wire_shift()]);
let coset = self.coset_ext_circuit(builder, vars.local_wires[self.wire_shift()]);
for (i, point) in coset.into_iter().enumerate() {
let value = vars.get_local_ext_algebra(self.wires_value(i));
let computed_value = interpolant.eval_scalar(builder, point);

2
plonky2/src/gates/low_degree_interpolation.rs
View File

@ -184,7 +184,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for LowDegreeInter
yield_constr.many((evaluation_value - computed_evaluation_value).to_basefield_array());
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
plonky2/src/gates/multiplication_extension.rs
View File

@ -84,7 +84,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for MulExtensionGa
}
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
plonky2/src/gates/noop.rs
View File

@ -23,7 +23,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for NoopGate {
Vec::new()
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
_builder: &mut CircuitBuilder<F, D>,
_vars: EvaluationTargets<D>,

32
plonky2/src/gates/poseidon.rs
View File

@ -265,7 +265,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PoseidonGate<F
}
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,
@ -306,7 +306,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PoseidonGate<F
// First set of full rounds.
for r in 0..poseidon::HALF_N_FULL_ROUNDS {
<F as Poseidon>::constant_layer_recursive(builder, &mut state, round_ctr);
<F as Poseidon>::constant_layer_circuit(builder, &mut state, round_ctr);
if r != 0 {
for i in 0..SPONGE_WIDTH {
let sbox_in = vars.local_wires[Self::wire_full_sbox_0(r, i)];
@ -314,38 +314,38 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PoseidonGate<F
state[i] = sbox_in;
}
}
<F as Poseidon>::sbox_layer_recursive(builder, &mut state);
state = <F as Poseidon>::mds_layer_recursive(builder, &state);
<F as Poseidon>::sbox_layer_circuit(builder, &mut state);
state = <F as Poseidon>::mds_layer_circuit(builder, &state);
round_ctr += 1;
}
// Partial rounds.
if use_mds_gate {
for r in 0..poseidon::N_PARTIAL_ROUNDS {
<F as Poseidon>::constant_layer_recursive(builder, &mut state, round_ctr);
<F as Poseidon>::constant_layer_circuit(builder, &mut state, round_ctr);
let sbox_in = vars.local_wires[Self::wire_partial_sbox(r)];
constraints.push(builder.sub_extension(state[0], sbox_in));
state[0] = <F as Poseidon>::sbox_monomial_recursive(builder, sbox_in);
state = <F as Poseidon>::mds_layer_recursive(builder, &state);
state[0] = <F as Poseidon>::sbox_monomial_circuit(builder, sbox_in);
state = <F as Poseidon>::mds_layer_circuit(builder, &state);
round_ctr += 1;
}
} else {
<F as Poseidon>::partial_first_constant_layer_recursive(builder, &mut state);
state = <F as Poseidon>::mds_partial_layer_init_recursive(builder, &state);
<F as Poseidon>::partial_first_constant_layer_circuit(builder, &mut state);
state = <F as Poseidon>::mds_partial_layer_init_circuit(builder, &state);
for r in 0..(poseidon::N_PARTIAL_ROUNDS - 1) {
let sbox_in = vars.local_wires[Self::wire_partial_sbox(r)];
constraints.push(builder.sub_extension(state[0], sbox_in));
state[0] = <F as Poseidon>::sbox_monomial_recursive(builder, sbox_in);
state[0] = <F as Poseidon>::sbox_monomial_circuit(builder, sbox_in);
let c = <F as Poseidon>::FAST_PARTIAL_ROUND_CONSTANTS[r];
let c = F::Extension::from_canonical_u64(c);
let c = builder.constant_extension(c);
state[0] = builder.add_extension(state[0], c);
state = <F as Poseidon>::mds_partial_layer_fast_recursive(builder, &state, r);
state = <F as Poseidon>::mds_partial_layer_fast_circuit(builder, &state, r);
}
let sbox_in = vars.local_wires[Self::wire_partial_sbox(poseidon::N_PARTIAL_ROUNDS - 1)];
constraints.push(builder.sub_extension(state[0], sbox_in));
state[0] = <F as Poseidon>::sbox_monomial_recursive(builder, sbox_in);
state = <F as Poseidon>::mds_partial_layer_fast_recursive(
state[0] = <F as Poseidon>::sbox_monomial_circuit(builder, sbox_in);
state = <F as Poseidon>::mds_partial_layer_fast_circuit(
builder,
&state,
poseidon::N_PARTIAL_ROUNDS - 1,
@ -355,14 +355,14 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PoseidonGate<F
// Second set of full rounds.
for r in 0..poseidon::HALF_N_FULL_ROUNDS {
<F as Poseidon>::constant_layer_recursive(builder, &mut state, round_ctr);
<F as Poseidon>::constant_layer_circuit(builder, &mut state, round_ctr);
for i in 0..SPONGE_WIDTH {
let sbox_in = vars.local_wires[Self::wire_full_sbox_1(r, i)];
constraints.push(builder.sub_extension(state[i], sbox_in));
state[i] = sbox_in;
}
<F as Poseidon>::sbox_layer_recursive(builder, &mut state);
state = <F as Poseidon>::mds_layer_recursive(builder, &state);
<F as Poseidon>::sbox_layer_circuit(builder, &mut state);
state = <F as Poseidon>::mds_layer_circuit(builder, &state);
round_ctr += 1;
}

10
plonky2/src/gates/poseidon_mds.rs
View File

@ -63,7 +63,7 @@ impl<F: RichField + Extendable<D> + Poseidon, const D: usize> PoseidonMdsGate<F,
}
/// Same as `mds_row_shf_recursive` for an extension algebra of `F`.
fn mds_row_shf_algebra_recursive(
fn mds_row_shf_algebra_circuit(
builder: &mut CircuitBuilder<F, D>,
r: usize,
v: &[ExtensionAlgebraTarget<D>; SPONGE_WIDTH],
@ -101,14 +101,14 @@ impl<F: RichField + Extendable<D> + Poseidon, const D: usize> PoseidonMdsGate<F,
}
/// Same as `mds_layer_recursive` for an extension algebra of `F`.
fn mds_layer_algebra_recursive(
fn mds_layer_algebra_circuit(
builder: &mut CircuitBuilder<F, D>,
state: &[ExtensionAlgebraTarget<D>; SPONGE_WIDTH],
) -> [ExtensionAlgebraTarget<D>; SPONGE_WIDTH] {
let mut result = [builder.zero_ext_algebra(); SPONGE_WIDTH];
for r in 0..SPONGE_WIDTH {
result[r] = Self::mds_row_shf_algebra_recursive(builder, r, state);
result[r] = Self::mds_row_shf_algebra_circuit(builder, r, state);
}
result
@ -157,7 +157,7 @@ impl<F: RichField + Extendable<D> + Poseidon, const D: usize> Gate<F, D> for Pos
)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,
@ -168,7 +168,7 @@ impl<F: RichField + Extendable<D> + Poseidon, const D: usize> Gate<F, D> for Pos
.try_into()
.unwrap();
let computed_outputs = Self::mds_layer_algebra_recursive(builder, &inputs);
let computed_outputs = Self::mds_layer_algebra_circuit(builder, &inputs);
(0..SPONGE_WIDTH)
.map(|i| vars.get_local_ext_algebra(Self::wires_output(i)))

2
plonky2/src/gates/public_input.rs
View File

@ -48,7 +48,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PublicInputGat
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
plonky2/src/gates/random_access.rs
View File

@ -161,7 +161,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for RandomAccessGa
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
plonky2/src/gates/reducing.rs
View File

@ -104,7 +104,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ReducingGate<D
}
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
plonky2/src/gates/reducing_extension.rs
View File

@ -105,7 +105,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ReducingExtens
}
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

20
plonky2/src/hash/poseidon.rs
View File

@ -207,7 +207,7 @@ pub trait Poseidon: PrimeField64 {
}
/// Recursive version of `mds_row_shf`.
fn mds_row_shf_recursive<const D: usize>(
fn mds_row_shf_circuit<const D: usize>(
builder: &mut CircuitBuilder<Self, D>,
r: usize,
v: &[ExtensionTarget<D>; WIDTH],
@ -267,7 +267,7 @@ pub trait Poseidon: PrimeField64 {
}
/// Recursive version of `mds_layer`.
fn mds_layer_recursive<const D: usize>(
fn mds_layer_circuit<const D: usize>(
builder: &mut CircuitBuilder<Self, D>,
state: &[ExtensionTarget<D>; WIDTH],
) -> [ExtensionTarget<D>; WIDTH]
@ -294,7 +294,7 @@ pub trait Poseidon: PrimeField64 {
let mut result = [builder.zero_extension(); WIDTH];
for r in 0..WIDTH {
result[r] = Self::mds_row_shf_recursive(builder, r, state);
result[r] = Self::mds_row_shf_circuit(builder, r, state);
}
result
@ -314,7 +314,7 @@ pub trait Poseidon: PrimeField64 {
}
/// Recursive version of `partial_first_constant_layer`.
fn partial_first_constant_layer_recursive<const D: usize>(
fn partial_first_constant_layer_circuit<const D: usize>(
builder: &mut CircuitBuilder<Self, D>,
state: &mut [ExtensionTarget<D>; WIDTH],
) where
@ -359,7 +359,7 @@ pub trait Poseidon: PrimeField64 {
}
/// Recursive version of `mds_partial_layer_init`.
fn mds_partial_layer_init_recursive<const D: usize>(
fn mds_partial_layer_init_circuit<const D: usize>(
builder: &mut CircuitBuilder<Self, D>,
state: &[ExtensionTarget<D>; WIDTH],
) -> [ExtensionTarget<D>; WIDTH]
@ -443,7 +443,7 @@ pub trait Poseidon: PrimeField64 {
}
/// Recursive version of `mds_partial_layer_fast`.
fn mds_partial_layer_fast_recursive<const D: usize>(
fn mds_partial_layer_fast_circuit<const D: usize>(
builder: &mut CircuitBuilder<Self, D>,
state: &[ExtensionTarget<D>; WIDTH],
r: usize,
@ -496,7 +496,7 @@ pub trait Poseidon: PrimeField64 {
}
/// Recursive version of `constant_layer`.
fn constant_layer_recursive<const D: usize>(
fn constant_layer_circuit<const D: usize>(
builder: &mut CircuitBuilder<Self, D>,
state: &mut [ExtensionTarget<D>; WIDTH],
round_ctr: usize,
@ -521,7 +521,7 @@ pub trait Poseidon: PrimeField64 {
}
/// Recursive version of `sbox_monomial`.
fn sbox_monomial_recursive<const D: usize>(
fn sbox_monomial_circuit<const D: usize>(
builder: &mut CircuitBuilder<Self, D>,
x: ExtensionTarget<D>,
) -> ExtensionTarget<D>
@ -552,14 +552,14 @@ pub trait Poseidon: PrimeField64 {
}
/// Recursive version of `sbox_layer`.
fn sbox_layer_recursive<const D: usize>(
fn sbox_layer_circuit<const D: usize>(
builder: &mut CircuitBuilder<Self, D>,
state: &mut [ExtensionTarget<D>; WIDTH],
) where
Self: RichField + Extendable<D>,
{
for i in 0..WIDTH {
state[i] = <Self as Poseidon>::sbox_monomial_recursive(builder, state[i]);
state[i] = <Self as Poseidon>::sbox_monomial_circuit(builder, state[i]);
}
}

4
plonky2/src/plonk/plonk_common.rs
View File

@ -81,7 +81,7 @@ pub(crate) fn eval_l_1<F: Field>(n: usize, x: F) -> F {
/// the order-`n` subgroup.
///
/// Assumes `x != 1`; if `x` could be 1 then this is unsound.
pub(crate) fn eval_l_1_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_l_1_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
n: usize,
x: ExtensionTarget<D>,
@ -138,7 +138,7 @@ where
sum
}
pub fn reduce_with_powers_ext_recursive<F: RichField + Extendable<D>, const D: usize>(
pub fn reduce_with_powers_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
terms: &[ExtensionTarget<D>],
alpha: Target,

4
plonky2/src/plonk/recursive_verifier.rs
View File

@ -8,7 +8,7 @@ use crate::plonk::plonk_common::salt_size;
use crate::plonk::proof::{
OpeningSetTarget, ProofChallengesTarget, ProofTarget, ProofWithPublicInputsTarget,
};
use crate::plonk::vanishing_poly::eval_vanishing_poly_recursively;
use crate::plonk::vanishing_poly::eval_vanishing_poly_circuit;
use crate::plonk::vars::EvaluationTargets;
use crate::util::reducing::ReducingFactorTarget;
use crate::with_context;
@ -70,7 +70,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
let vanishing_polys_zeta = with_context!(
self,
"evaluate the vanishing polynomial at our challenge point, zeta.",
eval_vanishing_poly_recursively(
eval_vanishing_poly_circuit(
self,
inner_common_data,
challenges.plonk_zeta,

16
plonky2/src/plonk/vanishing_poly.rs
View File

@ -10,9 +10,9 @@ use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CommonCircuitData;
use crate::plonk::config::GenericConfig;
use crate::plonk::plonk_common;
use crate::plonk::plonk_common::eval_l_1_recursively;
use crate::plonk::plonk_common::eval_l_1_circuit;
use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBaseBatch};
use crate::util::partial_products::{check_partial_products, check_partial_products_recursively};
use crate::util::partial_products::{check_partial_products, check_partial_products_circuit};
use crate::util::reducing::ReducingFactorTarget;
use crate::util::strided_view::PackedStridedView;
use crate::with_context;
@ -270,7 +270,7 @@ pub fn evaluate_gate_constraints_base_batch<
constraints_batch
}
pub fn evaluate_gate_constraints_recursively<
pub fn evaluate_gate_constraints_circuit<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
const D: usize,
@ -285,7 +285,7 @@ pub fn evaluate_gate_constraints_recursively<
with_context!(
builder,
&format!("evaluate {} constraints", gate.0.id()),
gate.0.eval_filtered_recursively(
gate.0.eval_filtered_circuit(
builder,
vars,
i,
@ -305,7 +305,7 @@ pub fn evaluate_gate_constraints_recursively<
///
/// Assumes `x != 1`; if `x` could be 1 then this is unsound. This is fine if `x` is a random
/// variable drawn from a sufficiently large domain.
pub(crate) fn eval_vanishing_poly_recursively<
pub(crate) fn eval_vanishing_poly_circuit<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
const D: usize,
@ -329,7 +329,7 @@ pub(crate) fn eval_vanishing_poly_recursively<
let constraint_terms = with_context!(
builder,
"evaluate gate constraints",
evaluate_gate_constraints_recursively(builder, common_data, vars,)
evaluate_gate_constraints_circuit(builder, common_data, vars,)
);
// The L_1(x) (Z(x) - 1) vanishing terms.
@ -337,7 +337,7 @@ pub(crate) fn eval_vanishing_poly_recursively<
// The terms checking the partial products.
let mut vanishing_partial_products_terms = Vec::new();
let l1_x = eval_l_1_recursively(builder, common_data.degree(), x, x_pow_deg);
let l1_x = eval_l_1_circuit(builder, common_data.degree(), x, x_pow_deg);
// Holds `k[i] * x`.
let mut s_ids = Vec::new();
@ -374,7 +374,7 @@ pub(crate) fn eval_vanishing_poly_recursively<
// The partial products considered for this iteration of `i`.
let current_partial_products = &partial_products[i * num_prods..(i + 1) * num_prods];
// Check the quotient partial products.
let partial_product_checks = check_partial_products_recursively(
let partial_product_checks = check_partial_products_circuit(
builder,
&numerator_values,
&denominator_values,

2
plonky2/src/util/partial_products.rs
View File

@ -77,7 +77,7 @@ pub(crate) fn check_partial_products<F: Field>(
/// Checks the relationship between each pair of partial product accumulators. In particular, this
/// sequence of accumulators starts with `Z(x)`, then contains each partial product polynomials
/// `p_i(x)`, and finally `Z(g x)`. See the partial products section of the Plonky2 paper.
pub(crate) fn check_partial_products_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn check_partial_products_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
numerators: &[ExtensionTarget<D>],
denominators: &[ExtensionTarget<D>],

8
starky/src/fibonacci_stark.rs
View File

@ -83,7 +83,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for FibonacciStar
);
}
fn eval_ext_recursively(
fn eval_ext_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: StarkEvaluationTargets<D, { Self::COLUMNS }, { Self::PUBLIC_INPUTS }>,
@ -138,8 +138,8 @@ mod tests {
use crate::proof::StarkProofWithPublicInputs;
use crate::prover::prove;
use crate::recursive_verifier::{
add_virtual_stark_proof_with_pis, recursively_verify_stark_proof,
set_stark_proof_with_pis_target,
add_virtual_stark_proof_with_pis, set_stark_proof_with_pis_target,
verify_stark_proof_circuit,
};
use crate::stark::Stark;
use crate::stark_testing::test_stark_low_degree;
@ -234,7 +234,7 @@ mod tests {
let pt = add_virtual_stark_proof_with_pis(&mut builder, stark, inner_config, degree_bits);
set_stark_proof_with_pis_target(&mut pw, &pt, &inner_proof);
recursively_verify_stark_proof::<F, InnerC, S, D>(&mut builder, stark, pt, inner_config);
verify_stark_proof_circuit::<F, InnerC, S, D>(&mut builder, stark, pt, inner_config);
if print_gate_counts {
builder.print_gate_counts(0);

2
starky/src/permutation.rs
View File

@ -325,7 +325,7 @@ pub struct PermutationCheckDataTarget<const D: usize> {
pub(crate) permutation_challenge_sets: Vec<PermutationChallengeSet<Target>>,
}
pub(crate) fn eval_permutation_checks_recursively<F, S, const D: usize>(
pub(crate) fn eval_permutation_checks_circuit<F, S, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
stark: &S,
config: &StarkConfig,

14
starky/src/recursive_verifier.rs
View File

@ -21,10 +21,10 @@ use crate::proof::{
StarkProofWithPublicInputs, StarkProofWithPublicInputsTarget,
};
use crate::stark::Stark;
use crate::vanishing_poly::eval_vanishing_poly_recursively;
use crate::vanishing_poly::eval_vanishing_poly_circuit;
use crate::vars::StarkEvaluationTargets;
pub fn recursively_verify_stark_proof<
pub fn verify_stark_proof_circuit<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
S: Stark<F, D>,
@ -47,7 +47,7 @@ pub fn recursively_verify_stark_proof<
proof_with_pis.get_challenges::<F, C, S>(builder, &stark, inner_config)
);
recursively_verify_stark_proof_with_challenges::<F, C, S, D>(
verify_stark_proof_with_challenges_circuit::<F, C, S, D>(
builder,
stark,
proof_with_pis,
@ -58,7 +58,7 @@ pub fn recursively_verify_stark_proof<
}
/// Recursively verifies an inner proof.
fn recursively_verify_stark_proof_with_challenges<
fn verify_stark_proof_with_challenges_circuit<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
S: Stark<F, D>,
@ -103,7 +103,7 @@ fn recursively_verify_stark_proof_with_challenges<
let zeta_pow_deg = builder.exp_power_of_2_extension(challenges.stark_zeta, degree_bits);
let z_h_zeta = builder.sub_extension(zeta_pow_deg, one);
let (l_1, l_last) =
eval_l_1_and_l_last_recursively(builder, degree_bits, challenges.stark_zeta, z_h_zeta);
eval_l_1_and_l_last_circuit(builder, degree_bits, challenges.stark_zeta, z_h_zeta);
let last =
builder.constant_extension(F::Extension::primitive_root_of_unity(degree_bits).inverse());
let z_last = builder.sub_extension(challenges.stark_zeta, last);
@ -127,7 +127,7 @@ fn recursively_verify_stark_proof_with_challenges<
with_context!(
builder,
"evaluate vanishing polynomial",
eval_vanishing_poly_recursively::<F, C, S, D>(
eval_vanishing_poly_circuit::<F, C, S, D>(
builder,
&stark,
inner_config,
@ -170,7 +170,7 @@ fn recursively_verify_stark_proof_with_challenges<
);
}
fn eval_l_1_and_l_last_recursively<F: RichField + Extendable<D>, const D: usize>(
fn eval_l_1_and_l_last_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
log_n: usize,
x: ExtensionTarget<D>,

2
starky/src/stark.rs
View File

@ -63,7 +63,7 @@ pub trait Stark<F: RichField + Extendable<D>, const D: usize>: Sync {
/// `eval_ext`, except in the context of a recursive circuit.
/// Note: constraints must be added through`yeld_constr.constraint(builder, constraint)` in the
/// same order as they are given in `eval_packed_generic`.
fn eval_ext_recursively(
fn eval_ext_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: StarkEvaluationTargets<D, { Self::COLUMNS }, { Self::PUBLIC_INPUTS }>,

8
starky/src/vanishing_poly.rs
View File

@ -7,7 +7,7 @@ use plonky2::plonk::config::GenericConfig;
use crate::config::StarkConfig;
use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::permutation::{
eval_permutation_checks, eval_permutation_checks_recursively, PermutationCheckDataTarget,
eval_permutation_checks, eval_permutation_checks_circuit, PermutationCheckDataTarget,
PermutationCheckVars,
};
use crate::stark::Stark;
@ -40,7 +40,7 @@ pub(crate) fn eval_vanishing_poly<F, FE, P, C, S, const D: usize, const D2: usiz
}
}
pub(crate) fn eval_vanishing_poly_recursively<F, C, S, const D: usize>(
pub(crate) fn eval_vanishing_poly_circuit<F, C, S, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
stark: &S,
config: &StarkConfig,
@ -54,9 +54,9 @@ pub(crate) fn eval_vanishing_poly_recursively<F, C, S, const D: usize>(
[(); S::COLUMNS]:,
[(); S::PUBLIC_INPUTS]:,
{
stark.eval_ext_recursively(builder, vars, consumer);
stark.eval_ext_circuit(builder, vars, consumer);
if let Some(permutation_data) = permutation_data {
eval_permutation_checks_recursively::<F, S, D>(
eval_permutation_checks_circuit::<F, S, D>(
builder,
stark,
config,

4
system_zero/src/alu/addition.rs
View File

@ -4,7 +4,7 @@ use plonky2::field::packed_field::PackedField;
use plonky2::hash::hash_types::RichField;
use plonky2::iop::ext_target::ExtensionTarget;
use plonky2::plonk::circuit_builder::CircuitBuilder;
use plonky2::plonk::plonk_common::reduce_with_powers_ext_recursive;
use plonky2::plonk::plonk_common::reduce_with_powers_ext_circuit;
use starky::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::registers::alu::*;
@ -60,7 +60,7 @@ pub(crate) fn eval_addition_recursively<F: RichField + Extendable<D>, const D: u
let limb_base = builder.constant(F::from_canonical_u64(1 << 16));
// Note that this can't overflow. Since each output limb has been range checked as 16-bits,
// this sum can be around 48 bits at most.
let out = reduce_with_powers_ext_recursive(builder, &[out_1, out_2, out_3], limb_base);
let out = reduce_with_powers_ext_circuit(builder, &[out_1, out_2, out_3], limb_base);
let computed_out = builder.add_many_extension(&[in_1, in_2, in_3]);

8
system_zero/src/alu/bitops.rs
View File

@ -4,7 +4,7 @@ use plonky2::field::packed_field::PackedField;
use plonky2::hash::hash_types::RichField;
use plonky2::iop::ext_target::ExtensionTarget;
use plonky2::plonk::circuit_builder::CircuitBuilder;
use plonky2::plonk::plonk_common::reduce_with_powers_ext_recursive;
use plonky2::plonk::plonk_common::reduce_with_powers_ext_circuit;
use starky::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::registers::alu::*;
@ -171,12 +171,12 @@ fn eval_bitop_32_recursively<F: RichField + Extendable<D>, const D: usize>(
let output = lv[output_reg];
let limb_base = builder.constant(F::TWO);
let a = reduce_with_powers_ext_recursive(builder, &a_bits, limb_base);
let b = reduce_with_powers_ext_recursive(builder, &b_bits, limb_base);
let a = reduce_with_powers_ext_circuit(builder, &a_bits, limb_base);
let b = reduce_with_powers_ext_circuit(builder, &b_bits, limb_base);
let a_and_b_bits = a_bits
.zip(b_bits)
.map(|(b0, b1)| builder.mul_extension(b0, b1));
let a_and_b = reduce_with_powers_ext_recursive(builder, &a_and_b_bits, limb_base);
let a_and_b = reduce_with_powers_ext_circuit(builder, &a_and_b_bits, limb_base);
let and_constr = {
let t = builder.sub_extension(a_and_b, output);

2
system_zero/src/alu/division.rs
View File

@ -90,7 +90,7 @@ pub(crate) fn eval_division<F: Field, P: PackedField<Scalar = F>>(
yield_constr.constraint(is_div * divisor * (divisor - remainder - F::ONE - div_rem_diff_m1));
}
pub(crate) fn eval_division_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_division_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,

16
system_zero/src/alu/mod.rs
View File

@ -9,16 +9,14 @@ use starky::vars::StarkEvaluationVars;
use crate::alu::addition::{eval_addition, eval_addition_recursively, generate_addition};
use crate::alu::bitops::{eval_bitop, eval_bitop_recursively, generate_bitop};
use crate::alu::division::{eval_division, eval_division_recursively, generate_division};
use crate::alu::mul_add::{eval_mul_add, eval_mul_add_recursively, generate_mul_add};
use crate::alu::division::{eval_division, eval_division_circuit, generate_division};
use crate::alu::mul_add::{eval_mul_add, eval_mul_add_circuit, generate_mul_add};
use crate::alu::rotate_shift::{
eval_rotate_left, eval_rotate_left_recursively, eval_rotate_right,
eval_rotate_right_recursively, eval_shift_left, eval_shift_left_recursively, eval_shift_right,
eval_shift_right_recursively, generate_rotate_shift,
};
use crate::alu::subtraction::{
eval_subtraction, eval_subtraction_recursively, generate_subtraction,
};
use crate::alu::subtraction::{eval_subtraction, eval_subtraction_circuit, generate_subtraction};
use crate::public_input_layout::NUM_PUBLIC_INPUTS;
use crate::registers::alu::*;
use crate::registers::NUM_COLUMNS;
@ -84,7 +82,7 @@ pub(crate) fn eval_alu<F: Field, P: PackedField<Scalar = F>>(
eval_shift_right(local_values, yield_constr);
}
pub(crate) fn eval_alu_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_alu_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
vars: StarkEvaluationTargets<D, NUM_COLUMNS, NUM_PUBLIC_INPUTS>,
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
@ -99,9 +97,9 @@ pub(crate) fn eval_alu_recursively<F: RichField + Extendable<D>, const D: usize>
}
eval_addition_recursively(builder, local_values, yield_constr);
eval_subtraction_recursively(builder, local_values, yield_constr);
eval_mul_add_recursively(builder, local_values, yield_constr);
eval_division_recursively(builder, local_values, yield_constr);
eval_subtraction_circuit(builder, local_values, yield_constr);
eval_mul_add_circuit(builder, local_values, yield_constr);
eval_division_circuit(builder, local_values, yield_constr);
eval_bitop_recursively(builder, local_values, yield_constr);
eval_rotate_left_recursively(builder, local_values, yield_constr);
eval_rotate_right_recursively(builder, local_values, yield_constr);

2
system_zero/src/alu/mul_add.rs
View File

@ -59,7 +59,7 @@ pub(crate) fn eval_mul_add<F: Field, P: PackedField<Scalar = F>>(
yield_constr.constraint(is_mul * (computed_output - output));
}
pub(crate) fn eval_mul_add_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_mul_add_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
local_values: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,

2
system_zero/src/alu/subtraction.rs
View File

@ -45,7 +45,7 @@ pub(crate) fn eval_subtraction<F: Field, P: PackedField<Scalar = F>>(
// checked by boolean::col_bit(0) in the ALU.
}
pub(crate) fn eval_subtraction_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_subtraction_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
local_values: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,

2
system_zero/src/core_registers.rs
View File

@ -62,7 +62,7 @@ pub(crate) fn eval_core_registers<F: Field, P: PackedField<Scalar = F>>(
// TODO constraints for stack etc.
}
pub(crate) fn eval_core_registers_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_core_registers_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
vars: StarkEvaluationTargets<D, NUM_COLUMNS, NUM_PUBLIC_INPUTS>,
yield_constr: &mut RecursiveConstraintConsumer<F, D>,

2
system_zero/src/lookup.rs
View File

@ -121,7 +121,7 @@ pub(crate) fn eval_lookups<F: Field, P: PackedField<Scalar = F>>(
}
}
pub(crate) fn eval_lookups_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_lookups_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
vars: StarkEvaluationTargets<D, NUM_COLUMNS, NUM_PUBLIC_INPUTS>,
yield_constr: &mut RecursiveConstraintConsumer<F, D>,

12
system_zero/src/permutation_unit.rs
View File

@ -187,7 +187,7 @@ pub(crate) fn eval_permutation_unit_recursively<F: RichField + Extendable<D>, co
}
for r in 0..HALF_N_FULL_ROUNDS {
F::constant_layer_recursive(builder, &mut state, r);
F::constant_layer_circuit(builder, &mut state, r);
for i in 0..SPONGE_WIDTH {
let state_cubed = builder.cube_extension(state[i]);
@ -199,7 +199,7 @@ pub(crate) fn eval_permutation_unit_recursively<F: RichField + Extendable<D>, co
// Form state ** 7.
}
state = F::mds_layer_recursive(builder, &state);
state = F::mds_layer_circuit(builder, &state);
for i in 0..SPONGE_WIDTH {
let diff =
@ -210,7 +210,7 @@ pub(crate) fn eval_permutation_unit_recursively<F: RichField + Extendable<D>, co
}
for r in 0..N_PARTIAL_ROUNDS {
F::constant_layer_recursive(builder, &mut state, HALF_N_FULL_ROUNDS + r);
F::constant_layer_circuit(builder, &mut state, HALF_N_FULL_ROUNDS + r);
let state0_cubed = builder.cube_extension(state[0]);
let diff = builder.sub_extension(state0_cubed, local_values[col_partial_mid_sbox(r)]);
@ -221,11 +221,11 @@ pub(crate) fn eval_permutation_unit_recursively<F: RichField + Extendable<D>, co
yield_constr.constraint(builder, diff);
state[0] = local_values[col_partial_after_sbox(r)];
state = F::mds_layer_recursive(builder, &state);
state = F::mds_layer_circuit(builder, &state);
}
for r in 0..HALF_N_FULL_ROUNDS {
F::constant_layer_recursive(
F::constant_layer_circuit(
builder,
&mut state,
HALF_N_FULL_ROUNDS + N_PARTIAL_ROUNDS + r,
@ -241,7 +241,7 @@ pub(crate) fn eval_permutation_unit_recursively<F: RichField + Extendable<D>, co
// Form state ** 7.
}
state = F::mds_layer_recursive(builder, &state);
state = F::mds_layer_circuit(builder, &state);
for i in 0..SPONGE_WIDTH {
let diff =

14
system_zero/src/system_zero.rs
View File

@ -14,12 +14,12 @@ use starky::stark::Stark;
use starky::vars::StarkEvaluationTargets;
use starky::vars::StarkEvaluationVars;
use crate::alu::{eval_alu, eval_alu_recursively, generate_alu};
use crate::alu::{eval_alu, eval_alu_circuit, generate_alu};
use crate::core_registers::{
eval_core_registers, eval_core_registers_recursively, generate_first_row_core_registers,
eval_core_registers, eval_core_registers_circuit, generate_first_row_core_registers,
generate_next_row_core_registers,
};
use crate::lookup::{eval_lookups, eval_lookups_recursively, generate_lookups};
use crate::lookup::{eval_lookups, eval_lookups_circuit, generate_lookups};
use crate::memory::TransactionMemory;
use crate::permutation_unit::{
eval_permutation_unit, eval_permutation_unit_recursively, generate_permutation_unit,
@ -135,16 +135,16 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for SystemZero<F,
// TODO: Other units
}
fn eval_ext_recursively(
fn eval_ext_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: StarkEvaluationTargets<D, NUM_COLUMNS, NUM_PUBLIC_INPUTS>,
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
) {
eval_core_registers_recursively(builder, vars, yield_constr);
eval_alu_recursively(builder, vars, yield_constr);
eval_core_registers_circuit(builder, vars, yield_constr);
eval_alu_circuit(builder, vars, yield_constr);
eval_permutation_unit_recursively(builder, vars, yield_constr);
eval_lookups_recursively(builder, vars, yield_constr);
eval_lookups_circuit(builder, vars, yield_constr);
// TODO: Other units
}

2
u32/src/gates/add_many_u32.rs
View File

@ -172,7 +172,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for U32AddManyGate
}
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
u32/src/gates/arithmetic_u32.rs
View File

@ -136,7 +136,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for U32ArithmeticG
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

10
u32/src/gates/comparison.rs
View File

@ -10,7 +10,7 @@ use plonky2::iop::target::Target;
use plonky2::iop::wire::Wire;
use plonky2::iop::witness::{PartitionWitness, Witness};
use plonky2::plonk::circuit_builder::CircuitBuilder;
use plonky2::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_recursive};
use plonky2::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_circuit};
use plonky2::plonk::vars::{
EvaluationTargets, EvaluationVars, EvaluationVarsBase, EvaluationVarsBaseBatch,
EvaluationVarsBasePacked,
@ -185,7 +185,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,
@ -205,9 +205,9 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
let chunk_base = builder.constant(F::from_canonical_usize(1 << self.chunk_bits()));
let first_chunks_combined =
reduce_with_powers_ext_recursive(builder, &first_chunks, chunk_base);
reduce_with_powers_ext_circuit(builder, &first_chunks, chunk_base);
let second_chunks_combined =
reduce_with_powers_ext_recursive(builder, &second_chunks, chunk_base);
reduce_with_powers_ext_circuit(builder, &second_chunks, chunk_base);
constraints.push(builder.sub_extension(first_chunks_combined, first_input));
constraints.push(builder.sub_extension(second_chunks_combined, second_input));
@ -268,7 +268,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
let two = builder.two();
let bits_combined =
reduce_with_powers_ext_recursive(builder, &most_significant_diff_bits, two);
reduce_with_powers_ext_circuit(builder, &most_significant_diff_bits, two);
let two_n =
builder.constant_extension(F::Extension::from_canonical_u64(1 << self.chunk_bits()));
let sum = builder.add_extension(two_n, most_significant_diff);

6
u32/src/gates/range_check_u32.rs
View File

@ -8,7 +8,7 @@ use plonky2::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator
use plonky2::iop::target::Target;
use plonky2::iop::witness::{PartitionWitness, Witness};
use plonky2::plonk::circuit_builder::CircuitBuilder;
use plonky2::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_recursive};
use plonky2::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_circuit};
use plonky2::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase};
use plonky2_field::extension_field::Extendable;
use plonky2_field::field_types::Field;
@ -99,7 +99,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for U32RangeCheckG
}
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,
@ -112,7 +112,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for U32RangeCheckG
let aux_limbs: Vec<_> = (0..self.aux_limbs_per_input_limb())
.map(|j| vars.local_wires[self.wire_ith_input_limb_jth_aux_limb(i, j)])
.collect();
let computed_sum = reduce_with_powers_ext_recursive(builder, &aux_limbs, base);
let computed_sum = reduce_with_powers_ext_circuit(builder, &aux_limbs, base);
constraints.push(builder.sub_extension(computed_sum, input_limb));
for aux_limb in aux_limbs {

2
u32/src/gates/subtraction_u32.rs
View File

@ -132,7 +132,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for U32Subtraction
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

2
waksman/src/gates/switch.rs
View File

@ -112,7 +112,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for SwitchGate<F,
self.eval_unfiltered_base_batch_packed(vars_base)
}
fn eval_unfiltered_recursively(
fn eval_unfiltered_circuit(
&self,
builder: &mut CircuitBuilder<F, D>,
vars: EvaluationTargets<D>,

30
waksman/src/permutation.rs
View File

@ -12,7 +12,7 @@ use crate::bimap::bimap_from_lists;
use crate::gates::switch::SwitchGate;
/// Assert that two lists of expressions evaluate to permutations of one another.
pub fn assert_permutation<F: RichField + Extendable<D>, const D: usize>(
pub fn assert_permutation_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
a: Vec<Vec<Target>>,
b: Vec<Vec<Target>>,
@ -35,7 +35,7 @@ pub fn assert_permutation<F: RichField + Extendable<D>, const D: usize>(
builder.connect(a[0][e], b[0][e])
}
}
2 => assert_permutation_2x2(
2 => assert_permutation_2x2_circuit(
builder,
a[0].clone(),
a[1].clone(),
@ -43,12 +43,12 @@ pub fn assert_permutation<F: RichField + Extendable<D>, const D: usize>(
b[1].clone(),
),
// For larger lists, we recursively use two smaller permutation networks.
_ => assert_permutation_recursive(builder, a, b),
_ => assert_permutation_helper_circuit(builder, a, b),
}
}
/// Assert that [a1, a2] is a permutation of [b1, b2].
fn assert_permutation_2x2<F: RichField + Extendable<D>, const D: usize>(
fn assert_permutation_2x2_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
a1: Vec<Target>,
a2: Vec<Target>,
@ -62,7 +62,7 @@ fn assert_permutation_2x2<F: RichField + Extendable<D>, const D: usize>(
let chunk_size = a1.len();
let (_switch, gate_out1, gate_out2) = create_switch(builder, a1, a2);
let (_switch, gate_out1, gate_out2) = create_switch_circuit(builder, a1, a2);
for e in 0..chunk_size {
builder.connect(b1[e], gate_out1[e]);
builder.connect(b2[e], gate_out2[e]);
@ -71,7 +71,7 @@ fn assert_permutation_2x2<F: RichField + Extendable<D>, const D: usize>(
/// Given two input wire chunks, add a new switch to the circuit (by adding one copy to a switch
/// gate). Returns the wire for the switch boolean, and the two output wire chunks.
fn create_switch<F: RichField + Extendable<D>, const D: usize>(
fn create_switch_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
a1: Vec<Target>,
a2: Vec<Target>,
@ -110,7 +110,7 @@ fn create_switch<F: RichField + Extendable<D>, const D: usize>(
(switch, c, d)
}
fn assert_permutation_recursive<F: RichField + Extendable<D>, const D: usize>(
fn assert_permutation_helper_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
a: Vec<Vec<Target>>,
b: Vec<Vec<Target>>,
@ -141,13 +141,15 @@ fn assert_permutation_recursive<F: RichField + Extendable<D>, const D: usize>(
let mut a_switches = Vec::new();
let mut b_switches = Vec::new();
for i in 0..a_num_switches {
let (switch, out_1, out_2) = create_switch(builder, a[i * 2].clone(), a[i * 2 + 1].clone());
let (switch, out_1, out_2) =
create_switch_circuit(builder, a[i * 2].clone(), a[i * 2 + 1].clone());
a_switches.push(switch);
child_1_a.push(out_1);
child_2_a.push(out_2);
}
for i in 0..b_num_switches {
let (switch, out_1, out_2) = create_switch(builder, b[i * 2].clone(), b[i * 2 + 1].clone());
let (switch, out_1, out_2) =
create_switch_circuit(builder, b[i * 2].clone(), b[i * 2 + 1].clone());
b_switches.push(switch);
child_1_b.push(out_1);
child_2_b.push(out_2);
@ -162,8 +164,8 @@ fn assert_permutation_recursive<F: RichField + Extendable<D>, const D: usize>(
child_2_b.push(b[n - 1].clone());
}
assert_permutation(builder, child_1_a, child_1_b);
assert_permutation(builder, child_2_a, child_2_b);
assert_permutation_circuit(builder, child_1_a, child_1_b);
assert_permutation_circuit(builder, child_2_a, child_2_b);
builder.add_simple_generator(PermutationGenerator::<F> {
a,
@ -400,7 +402,7 @@ mod tests {
let mut b = a.clone();
b.shuffle(&mut thread_rng());
assert_permutation(&mut builder, a, b);
assert_permutation_circuit(&mut builder, a, b);
let data = builder.build::<C>();
let proof = data.prove(pw)?;
@ -430,7 +432,7 @@ mod tests {
let mut b = a.clone();
b.shuffle(&mut thread_rng());
assert_permutation(&mut builder, a, b);
assert_permutation_circuit(&mut builder, a, b);
let data = builder.build::<C>();
let proof = data.prove(pw)?;
@ -459,7 +461,7 @@ mod tests {
.map(|pair| vec![builder.constant(pair[0]), builder.constant(pair[1])])
.collect();
assert_permutation(&mut builder, a, b);
assert_permutation_circuit(&mut builder, a, b);
let data = builder.build::<C>();
data.prove(pw)?;

16
waksman/src/sorting.rs
View File

@ -11,7 +11,7 @@ use plonky2::iop::witness::{PartitionWitness, Witness};
use plonky2::plonk::circuit_builder::CircuitBuilder;
use plonky2_util::ceil_div_usize;
use crate::permutation::assert_permutation;
use crate::permutation::assert_permutation_circuit;
pub struct MemoryOp<F: Field> {
is_write: bool,
@ -28,7 +28,7 @@ pub struct MemoryOpTarget {
value: Target,
}
pub fn assert_permutation_memory_ops<F: RichField + Extendable<D>, const D: usize>(
pub fn assert_permutation_memory_ops_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
a: &[MemoryOpTarget],
b: &[MemoryOpTarget],
@ -42,11 +42,11 @@ pub fn assert_permutation_memory_ops<F: RichField + Extendable<D>, const D: usiz
.map(|op| vec![op.address, op.timestamp, op.is_write.target, op.value])
.collect();
assert_permutation(builder, a_chunks, b_chunks);
assert_permutation_circuit(builder, a_chunks, b_chunks);
}
/// Add an AssertLessThanGate to assert that `lhs` is less than `rhs`, where their values are at most `bits` bits.
pub fn assert_le<F: RichField + Extendable<D>, const D: usize>(
pub fn assert_le_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lhs: Target,
rhs: Target,
@ -62,7 +62,7 @@ pub fn assert_le<F: RichField + Extendable<D>, const D: usize>(
/// Sort memory operations by address value, then by timestamp value.
/// This is done by combining address and timestamp into one field element (using their given bit lengths).
pub fn sort_memory_ops<F: RichField + Extendable<D>, const D: usize>(
pub fn sort_memory_ops_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
ops: &[MemoryOpTarget],
address_bits: usize,
@ -106,7 +106,7 @@ pub fn sort_memory_ops<F: RichField + Extendable<D>, const D: usize>(
.collect();
for i in 1..n {
assert_le(
assert_le_circuit(
builder,
address_timestamp_combined[i - 1],
address_timestamp_combined[i],
@ -115,7 +115,7 @@ pub fn sort_memory_ops<F: RichField + Extendable<D>, const D: usize>(
);
}
assert_permutation_memory_ops(builder, ops, &output_targets);
assert_permutation_memory_ops_circuit(builder, ops, &output_targets);
builder.add_simple_generator(MemoryOpSortGenerator::<F, D> {
input_ops: ops.to_vec(),
@ -237,7 +237,7 @@ mod tests {
input_ops_and_keys.sort_by_key(|(_, val)| *val);
let input_ops_sorted: Vec<_> = input_ops_and_keys.iter().map(|(x, _)| x).collect();
let output_ops = sort_memory_ops(
let output_ops = sort_memory_ops_circuit(
&mut builder,
input_ops.as_slice(),
address_bits,