diff --git a/insertion/src/insertion_gate.rs b/insertion/src/insertion_gate.rs index c727db83..e5991a19 100644 --- a/insertion/src/insertion_gate.rs +++ b/insertion/src/insertion_gate.rs @@ -153,7 +153,7 @@ impl, const D: usize> Gate for InsertionGate< } } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/gates/arithmetic_base.rs b/plonky2/src/gates/arithmetic_base.rs index 82f2e8f3..9aa3c51a 100644 --- a/plonky2/src/gates/arithmetic_base.rs +++ b/plonky2/src/gates/arithmetic_base.rs @@ -86,7 +86,7 @@ impl, const D: usize> Gate for ArithmeticGate self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/gates/arithmetic_extension.rs b/plonky2/src/gates/arithmetic_extension.rs index d8180779..66dcfdd2 100644 --- a/plonky2/src/gates/arithmetic_extension.rs +++ b/plonky2/src/gates/arithmetic_extension.rs @@ -93,7 +93,7 @@ impl, const D: usize> Gate for ArithmeticExte } } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/gates/assert_le.rs b/plonky2/src/gates/assert_le.rs index 9a5b2845..ac47b6f5 100644 --- a/plonky2/src/gates/assert_le.rs +++ b/plonky2/src/gates/assert_le.rs @@ -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, const D: usize> Gate for AssertLessThan self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, @@ -188,9 +188,9 @@ impl, const D: usize> Gate 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)); diff --git a/plonky2/src/gates/base_sum.rs b/plonky2/src/gates/base_sum.rs index adb90988..d26747de 100644 --- a/plonky2/src/gates/base_sum.rs +++ b/plonky2/src/gates/base_sum.rs @@ -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, const D: usize, const B: usize> Gate fo self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, @@ -85,7 +85,7 @@ impl, const D: usize, const B: usize> Gate 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({ diff --git a/plonky2/src/gates/constant.rs b/plonky2/src/gates/constant.rs index 14e5dc82..e0ebd9a0 100644 --- a/plonky2/src/gates/constant.rs +++ b/plonky2/src/gates/constant.rs @@ -56,7 +56,7 @@ impl, const D: usize> Gate for ConstantGate { self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/gates/exponentiation.rs b/plonky2/src/gates/exponentiation.rs index c8df4c35..179395f3 100644 --- a/plonky2/src/gates/exponentiation.rs +++ b/plonky2/src/gates/exponentiation.rs @@ -120,7 +120,7 @@ impl, const D: usize> Gate for Exponentiation self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/gates/gate.rs b/plonky2/src/gates/gate.rs index a33287e1..02811bf5 100644 --- a/plonky2/src/gates/gate.rs +++ b/plonky2/src/gates/gate.rs @@ -75,7 +75,7 @@ pub trait Gate, const D: usize>: 'static + Send + S res } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, @@ -132,7 +132,7 @@ pub trait Gate, 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, mut vars: EvaluationTargets, @@ -142,7 +142,7 @@ pub trait Gate, const D: usize>: 'static + Send + S num_selectors: usize, combined_gate_constraints: &mut [ExtensionTarget], ) { - let filter = compute_filter_recursively( + let filter = compute_filter_circuit( builder, row, group_range, @@ -150,7 +150,7 @@ pub trait Gate, 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); } @@ -249,7 +249,7 @@ fn compute_filter(row: usize, group_range: Range, s: K, many_se .product() } -fn compute_filter_recursively, const D: usize>( +fn compute_filter_circuit, const D: usize>( builder: &mut CircuitBuilder, row: usize, group_range: Range, diff --git a/plonky2/src/gates/gate_testing.rs b/plonky2/src/gates/gate_testing.rs index 51768ba8..a6e37adc 100644 --- a/plonky2/src/gates/gate_testing.rs +++ b/plonky2/src/gates/gate_testing.rs @@ -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::(); diff --git a/plonky2/src/gates/interpolation.rs b/plonky2/src/gates/interpolation.rs index 88f8216c..3bec5d1e 100644 --- a/plonky2/src/gates/interpolation.rs +++ b/plonky2/src/gates/interpolation.rs @@ -64,7 +64,7 @@ impl, const D: usize> HighDegreeInterpolationGate, shift: ExtensionTarget, @@ -134,7 +134,7 @@ impl, const D: usize> Gate yield_constr.many((evaluation_value - computed_evaluation_value).to_basefield_array()); } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, @@ -146,7 +146,7 @@ impl, const D: usize> Gate .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); diff --git a/plonky2/src/gates/low_degree_interpolation.rs b/plonky2/src/gates/low_degree_interpolation.rs index 501227bf..47f02be0 100644 --- a/plonky2/src/gates/low_degree_interpolation.rs +++ b/plonky2/src/gates/low_degree_interpolation.rs @@ -184,7 +184,7 @@ impl, const D: usize> Gate 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, vars: EvaluationTargets, diff --git a/plonky2/src/gates/multiplication_extension.rs b/plonky2/src/gates/multiplication_extension.rs index 592367aa..c5bfaef2 100644 --- a/plonky2/src/gates/multiplication_extension.rs +++ b/plonky2/src/gates/multiplication_extension.rs @@ -84,7 +84,7 @@ impl, const D: usize> Gate for MulExtensionGa } } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/gates/noop.rs b/plonky2/src/gates/noop.rs index 06cc9486..85375f01 100644 --- a/plonky2/src/gates/noop.rs +++ b/plonky2/src/gates/noop.rs @@ -23,7 +23,7 @@ impl, const D: usize> Gate for NoopGate { Vec::new() } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, _builder: &mut CircuitBuilder, _vars: EvaluationTargets, diff --git a/plonky2/src/gates/poseidon.rs b/plonky2/src/gates/poseidon.rs index 01386cd1..72b54b2d 100644 --- a/plonky2/src/gates/poseidon.rs +++ b/plonky2/src/gates/poseidon.rs @@ -265,7 +265,7 @@ impl, const D: usize> Gate for PoseidonGate, vars: EvaluationTargets, @@ -306,7 +306,7 @@ impl, const D: usize> Gate for PoseidonGate::constant_layer_recursive(builder, &mut state, round_ctr); + ::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, const D: usize> Gate for PoseidonGate::sbox_layer_recursive(builder, &mut state); - state = ::mds_layer_recursive(builder, &state); + ::sbox_layer_circuit(builder, &mut state); + state = ::mds_layer_circuit(builder, &state); round_ctr += 1; } // Partial rounds. if use_mds_gate { for r in 0..poseidon::N_PARTIAL_ROUNDS { - ::constant_layer_recursive(builder, &mut state, round_ctr); + ::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] = ::sbox_monomial_recursive(builder, sbox_in); - state = ::mds_layer_recursive(builder, &state); + state[0] = ::sbox_monomial_circuit(builder, sbox_in); + state = ::mds_layer_circuit(builder, &state); round_ctr += 1; } } else { - ::partial_first_constant_layer_recursive(builder, &mut state); - state = ::mds_partial_layer_init_recursive(builder, &state); + ::partial_first_constant_layer_circuit(builder, &mut state); + state = ::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] = ::sbox_monomial_recursive(builder, sbox_in); + state[0] = ::sbox_monomial_circuit(builder, sbox_in); let c = ::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 = ::mds_partial_layer_fast_recursive(builder, &state, r); + state = ::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] = ::sbox_monomial_recursive(builder, sbox_in); - state = ::mds_partial_layer_fast_recursive( + state[0] = ::sbox_monomial_circuit(builder, sbox_in); + state = ::mds_partial_layer_fast_circuit( builder, &state, poseidon::N_PARTIAL_ROUNDS - 1, @@ -355,14 +355,14 @@ impl, const D: usize> Gate for PoseidonGate::constant_layer_recursive(builder, &mut state, round_ctr); + ::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; } - ::sbox_layer_recursive(builder, &mut state); - state = ::mds_layer_recursive(builder, &state); + ::sbox_layer_circuit(builder, &mut state); + state = ::mds_layer_circuit(builder, &state); round_ctr += 1; } diff --git a/plonky2/src/gates/poseidon_mds.rs b/plonky2/src/gates/poseidon_mds.rs index d011fbd7..0d52cc5c 100644 --- a/plonky2/src/gates/poseidon_mds.rs +++ b/plonky2/src/gates/poseidon_mds.rs @@ -63,7 +63,7 @@ impl + Poseidon, const D: usize> PoseidonMdsGate, r: usize, v: &[ExtensionAlgebraTarget; SPONGE_WIDTH], @@ -101,14 +101,14 @@ impl + Poseidon, const D: usize> PoseidonMdsGate, state: &[ExtensionAlgebraTarget; SPONGE_WIDTH], ) -> [ExtensionAlgebraTarget; 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 + Poseidon, const D: usize> Gate for Pos ) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, @@ -168,7 +168,7 @@ impl + Poseidon, const D: usize> Gate 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))) diff --git a/plonky2/src/gates/public_input.rs b/plonky2/src/gates/public_input.rs index f970e404..3e3a4d4a 100644 --- a/plonky2/src/gates/public_input.rs +++ b/plonky2/src/gates/public_input.rs @@ -48,7 +48,7 @@ impl, const D: usize> Gate for PublicInputGat self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/gates/random_access.rs b/plonky2/src/gates/random_access.rs index 8a98021a..d99a591f 100644 --- a/plonky2/src/gates/random_access.rs +++ b/plonky2/src/gates/random_access.rs @@ -161,7 +161,7 @@ impl, const D: usize> Gate for RandomAccessGa self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/gates/reducing.rs b/plonky2/src/gates/reducing.rs index 98fba207..c29b9ff9 100644 --- a/plonky2/src/gates/reducing.rs +++ b/plonky2/src/gates/reducing.rs @@ -104,7 +104,7 @@ impl, const D: usize> Gate for ReducingGate, vars: EvaluationTargets, diff --git a/plonky2/src/gates/reducing_extension.rs b/plonky2/src/gates/reducing_extension.rs index 14f31404..dd454a4b 100644 --- a/plonky2/src/gates/reducing_extension.rs +++ b/plonky2/src/gates/reducing_extension.rs @@ -105,7 +105,7 @@ impl, const D: usize> Gate for ReducingExtens } } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/plonky2/src/hash/poseidon.rs b/plonky2/src/hash/poseidon.rs index 9c202834..7f168855 100644 --- a/plonky2/src/hash/poseidon.rs +++ b/plonky2/src/hash/poseidon.rs @@ -207,7 +207,7 @@ pub trait Poseidon: PrimeField64 { } /// Recursive version of `mds_row_shf`. - fn mds_row_shf_recursive( + fn mds_row_shf_circuit( builder: &mut CircuitBuilder, r: usize, v: &[ExtensionTarget; WIDTH], @@ -267,7 +267,7 @@ pub trait Poseidon: PrimeField64 { } /// Recursive version of `mds_layer`. - fn mds_layer_recursive( + fn mds_layer_circuit( builder: &mut CircuitBuilder, state: &[ExtensionTarget; WIDTH], ) -> [ExtensionTarget; 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( + fn partial_first_constant_layer_circuit( builder: &mut CircuitBuilder, state: &mut [ExtensionTarget; WIDTH], ) where @@ -359,7 +359,7 @@ pub trait Poseidon: PrimeField64 { } /// Recursive version of `mds_partial_layer_init`. - fn mds_partial_layer_init_recursive( + fn mds_partial_layer_init_circuit( builder: &mut CircuitBuilder, state: &[ExtensionTarget; WIDTH], ) -> [ExtensionTarget; WIDTH] @@ -443,7 +443,7 @@ pub trait Poseidon: PrimeField64 { } /// Recursive version of `mds_partial_layer_fast`. - fn mds_partial_layer_fast_recursive( + fn mds_partial_layer_fast_circuit( builder: &mut CircuitBuilder, state: &[ExtensionTarget; WIDTH], r: usize, @@ -496,7 +496,7 @@ pub trait Poseidon: PrimeField64 { } /// Recursive version of `constant_layer`. - fn constant_layer_recursive( + fn constant_layer_circuit( builder: &mut CircuitBuilder, state: &mut [ExtensionTarget; WIDTH], round_ctr: usize, @@ -521,7 +521,7 @@ pub trait Poseidon: PrimeField64 { } /// Recursive version of `sbox_monomial`. - fn sbox_monomial_recursive( + fn sbox_monomial_circuit( builder: &mut CircuitBuilder, x: ExtensionTarget, ) -> ExtensionTarget @@ -552,14 +552,14 @@ pub trait Poseidon: PrimeField64 { } /// Recursive version of `sbox_layer`. - fn sbox_layer_recursive( + fn sbox_layer_circuit( builder: &mut CircuitBuilder, state: &mut [ExtensionTarget; WIDTH], ) where Self: RichField + Extendable, { for i in 0..WIDTH { - state[i] = ::sbox_monomial_recursive(builder, state[i]); + state[i] = ::sbox_monomial_circuit(builder, state[i]); } } diff --git a/plonky2/src/plonk/plonk_common.rs b/plonky2/src/plonk/plonk_common.rs index 09cf2652..1cf14cda 100644 --- a/plonky2/src/plonk/plonk_common.rs +++ b/plonky2/src/plonk/plonk_common.rs @@ -81,7 +81,7 @@ pub(crate) fn eval_l_1(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, const D: usize>( +pub(crate) fn eval_l_1_circuit, const D: usize>( builder: &mut CircuitBuilder, n: usize, x: ExtensionTarget, @@ -138,7 +138,7 @@ where sum } -pub fn reduce_with_powers_ext_recursive, const D: usize>( +pub fn reduce_with_powers_ext_circuit, const D: usize>( builder: &mut CircuitBuilder, terms: &[ExtensionTarget], alpha: Target, diff --git a/plonky2/src/plonk/recursive_verifier.rs b/plonky2/src/plonk/recursive_verifier.rs index 2fe7d648..c30ab849 100644 --- a/plonky2/src/plonk/recursive_verifier.rs +++ b/plonky2/src/plonk/recursive_verifier.rs @@ -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, const D: usize> CircuitBuilder { 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, diff --git a/plonky2/src/plonk/vanishing_poly.rs b/plonky2/src/plonk/vanishing_poly.rs index ab23aa45..29facac0 100644 --- a/plonky2/src/plonk/vanishing_poly.rs +++ b/plonky2/src/plonk/vanishing_poly.rs @@ -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, C: GenericConfig, 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, C: GenericConfig, 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, diff --git a/plonky2/src/util/partial_products.rs b/plonky2/src/util/partial_products.rs index 56e9d6ed..9f9ebed4 100644 --- a/plonky2/src/util/partial_products.rs +++ b/plonky2/src/util/partial_products.rs @@ -77,7 +77,7 @@ pub(crate) fn check_partial_products( /// 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, const D: usize>( +pub(crate) fn check_partial_products_circuit, const D: usize>( builder: &mut CircuitBuilder, numerators: &[ExtensionTarget], denominators: &[ExtensionTarget], diff --git a/starky/src/fibonacci_stark.rs b/starky/src/fibonacci_stark.rs index fa9ccd87..3db38cda 100644 --- a/starky/src/fibonacci_stark.rs +++ b/starky/src/fibonacci_stark.rs @@ -83,7 +83,7 @@ impl, const D: usize> Stark for FibonacciStar ); } - fn eval_ext_recursively( + fn eval_ext_circuit( &self, builder: &mut CircuitBuilder, vars: StarkEvaluationTargets, @@ -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::(&mut builder, stark, pt, inner_config); + verify_stark_proof_circuit::(&mut builder, stark, pt, inner_config); if print_gate_counts { builder.print_gate_counts(0); diff --git a/starky/src/permutation.rs b/starky/src/permutation.rs index 443ff787..c96e8ae7 100644 --- a/starky/src/permutation.rs +++ b/starky/src/permutation.rs @@ -325,7 +325,7 @@ pub struct PermutationCheckDataTarget { pub(crate) permutation_challenge_sets: Vec>, } -pub(crate) fn eval_permutation_checks_recursively( +pub(crate) fn eval_permutation_checks_circuit( builder: &mut CircuitBuilder, stark: &S, config: &StarkConfig, diff --git a/starky/src/recursive_verifier.rs b/starky/src/recursive_verifier.rs index e091d64c..024491f4 100644 --- a/starky/src/recursive_verifier.rs +++ b/starky/src/recursive_verifier.rs @@ -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, C: GenericConfig, S: Stark, @@ -47,7 +47,7 @@ pub fn recursively_verify_stark_proof< proof_with_pis.get_challenges::(builder, &stark, inner_config) ); - recursively_verify_stark_proof_with_challenges::( + verify_stark_proof_with_challenges_circuit::( 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, C: GenericConfig, S: Stark, @@ -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::( + eval_vanishing_poly_circuit::( builder, &stark, inner_config, @@ -170,7 +170,7 @@ fn recursively_verify_stark_proof_with_challenges< ); } -fn eval_l_1_and_l_last_recursively, const D: usize>( +fn eval_l_1_and_l_last_circuit, const D: usize>( builder: &mut CircuitBuilder, log_n: usize, x: ExtensionTarget, @@ -233,12 +233,12 @@ pub fn add_virtual_stark_proof, S: Stark, con trace_cap: builder.add_virtual_cap(cap_height), permutation_zs_cap, quotient_polys_cap: builder.add_virtual_cap(cap_height), - openings: add_stark_opening_set::(builder, stark, config), + openings: add_stark_opening_set_target::(builder, stark, config), opening_proof: builder.add_virtual_fri_proof(&num_leaves_per_oracle, &fri_params), } } -fn add_stark_opening_set, S: Stark, const D: usize>( +fn add_stark_opening_set_target, S: Stark, const D: usize>( builder: &mut CircuitBuilder, stark: S, config: &StarkConfig, diff --git a/starky/src/stark.rs b/starky/src/stark.rs index a130d283..b4837ec6 100644 --- a/starky/src/stark.rs +++ b/starky/src/stark.rs @@ -63,7 +63,7 @@ pub trait Stark, 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, vars: StarkEvaluationTargets, diff --git a/starky/src/vanishing_poly.rs b/starky/src/vanishing_poly.rs index dc32b800..122f0191 100644 --- a/starky/src/vanishing_poly.rs +++ b/starky/src/vanishing_poly.rs @@ -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( +pub(crate) fn eval_vanishing_poly_circuit( builder: &mut CircuitBuilder, stark: &S, config: &StarkConfig, @@ -54,9 +54,9 @@ pub(crate) fn eval_vanishing_poly_recursively( [(); 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::( + eval_permutation_checks_circuit::( builder, stark, config, diff --git a/system_zero/src/alu/addition.rs b/system_zero/src/alu/addition.rs index c2293b4a..a2ddeea4 100644 --- a/system_zero/src/alu/addition.rs +++ b/system_zero/src/alu/addition.rs @@ -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::*; @@ -44,7 +44,7 @@ pub(crate) fn eval_addition>( yield_constr.constraint(is_add * (out - computed_out)); } -pub(crate) fn eval_addition_recursively, const D: usize>( +pub(crate) fn eval_addition_circuit, const D: usize>( builder: &mut CircuitBuilder, local_values: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, @@ -60,7 +60,7 @@ pub(crate) fn eval_addition_recursively, 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]); diff --git a/system_zero/src/alu/bitops.rs b/system_zero/src/alu/bitops.rs index 6e5cfc18..14501303 100644 --- a/system_zero/src/alu/bitops.rs +++ b/system_zero/src/alu/bitops.rs @@ -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::*; @@ -130,7 +130,7 @@ pub(crate) fn eval_bitop>( ); } -pub(crate) fn constrain_all_to_bits, const D: usize>( +pub(crate) fn constrain_all_to_bits_circuit, const D: usize>( builder: &mut CircuitBuilder, yield_constr: &mut RecursiveConstraintConsumer, filter: ExtensionTarget, @@ -144,7 +144,7 @@ pub(crate) fn constrain_all_to_bits, const D: usize } /// As for `eval_bitop`, but build with `builder`. -fn eval_bitop_32_recursively, const D: usize>( +fn eval_bitop_32_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], input_a_regs: [usize; 32], @@ -164,19 +164,19 @@ fn eval_bitop_32_recursively, const D: usize>( // Ensure that the inputs are bits let inst_constr = builder.add_many_extension(&[is_and, is_ior, is_xor, is_andnot]); - constrain_all_to_bits(builder, yield_constr, inst_constr, &a_bits); - constrain_all_to_bits(builder, yield_constr, inst_constr, &b_bits); + constrain_all_to_bits_circuit(builder, yield_constr, inst_constr, &a_bits); + constrain_all_to_bits_circuit(builder, yield_constr, inst_constr, &b_bits); // Output 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); @@ -209,13 +209,13 @@ fn eval_bitop_32_recursively, const D: usize>( } /// As for `eval_bitop` but with a builder. -pub(crate) fn eval_bitop_recursively, const D: usize>( +pub(crate) fn eval_bitop_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, ) { // Recursive constraint for lo half - eval_bitop_32_recursively( + eval_bitop_32_circuit( builder, lv, COL_BIT_DECOMP_INPUT_A_LO_BIN_REGS, @@ -224,7 +224,7 @@ pub(crate) fn eval_bitop_recursively, const D: usiz yield_constr, ); // Recursive constraint for hi half - eval_bitop_32_recursively( + eval_bitop_32_circuit( builder, lv, COL_BIT_DECOMP_INPUT_A_HI_BIN_REGS, diff --git a/system_zero/src/alu/division.rs b/system_zero/src/alu/division.rs index 801f96de..9d578ee9 100644 --- a/system_zero/src/alu/division.rs +++ b/system_zero/src/alu/division.rs @@ -90,7 +90,7 @@ pub(crate) fn eval_division>( yield_constr.constraint(is_div * divisor * (divisor - remainder - F::ONE - div_rem_diff_m1)); } -pub(crate) fn eval_division_recursively, const D: usize>( +pub(crate) fn eval_division_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, diff --git a/system_zero/src/alu/mod.rs b/system_zero/src/alu/mod.rs index 235283b4..c3f3b859 100644 --- a/system_zero/src/alu/mod.rs +++ b/system_zero/src/alu/mod.rs @@ -7,18 +7,16 @@ use starky::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsume use starky::vars::StarkEvaluationTargets; 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::addition::{eval_addition, eval_addition_circuit, generate_addition}; +use crate::alu::bitops::{eval_bitop, eval_bitop_circuit, generate_bitop}; +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, + eval_rotate_left, eval_rotate_left_circuit, eval_rotate_right, eval_rotate_right_circuit, + eval_shift_left, eval_shift_left_circuit, eval_shift_right, eval_shift_right_circuit, + generate_rotate_shift, }; +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>( eval_shift_right(local_values, yield_constr); } -pub(crate) fn eval_alu_recursively, const D: usize>( +pub(crate) fn eval_alu_circuit, const D: usize>( builder: &mut CircuitBuilder, vars: StarkEvaluationTargets, yield_constr: &mut RecursiveConstraintConsumer, @@ -98,13 +96,13 @@ pub(crate) fn eval_alu_recursively, const D: usize> yield_constr.constraint(builder, constraint); } - 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_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); - eval_shift_left_recursively(builder, local_values, yield_constr); - eval_shift_right_recursively(builder, local_values, yield_constr); + eval_addition_circuit(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_circuit(builder, local_values, yield_constr); + eval_rotate_left_circuit(builder, local_values, yield_constr); + eval_rotate_right_circuit(builder, local_values, yield_constr); + eval_shift_left_circuit(builder, local_values, yield_constr); + eval_shift_right_circuit(builder, local_values, yield_constr); } diff --git a/system_zero/src/alu/mul_add.rs b/system_zero/src/alu/mul_add.rs index b8ee26c1..1fb881d7 100644 --- a/system_zero/src/alu/mul_add.rs +++ b/system_zero/src/alu/mul_add.rs @@ -59,7 +59,7 @@ pub(crate) fn eval_mul_add>( yield_constr.constraint(is_mul * (computed_output - output)); } -pub(crate) fn eval_mul_add_recursively, const D: usize>( +pub(crate) fn eval_mul_add_circuit, const D: usize>( builder: &mut CircuitBuilder, local_values: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, diff --git a/system_zero/src/alu/rotate_shift.rs b/system_zero/src/alu/rotate_shift.rs index 697bd248..e23f3f92 100644 --- a/system_zero/src/alu/rotate_shift.rs +++ b/system_zero/src/alu/rotate_shift.rs @@ -6,7 +6,7 @@ use plonky2::iop::ext_target::ExtensionTarget; use plonky2::plonk::circuit_builder::CircuitBuilder; use starky::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer}; -use crate::alu::bitops::constrain_all_to_bits; +use crate::alu::bitops::constrain_all_to_bits_circuit; use crate::registers::alu::*; use crate::registers::NUM_COLUMNS; @@ -343,7 +343,7 @@ pub(crate) fn eval_shift_right>( yield_constr.constraint(is_shl * hi_constr); } -fn constrain_pow_exp_recursively, const D: usize>( +fn constrain_pow_exp_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, @@ -358,8 +358,8 @@ fn constrain_pow_exp_recursively, const D: usize>( let pow_exp = lv[COL_ROTATE_SHIFT_POW_EXP]; // Check that every "bit" of exp_bits and exp_ge32_bit is 0 or 1 - constrain_all_to_bits(builder, yield_constr, filter, &exp_bits); - constrain_all_to_bits(builder, yield_constr, filter, &[exp_ge32_bit]); + constrain_all_to_bits_circuit(builder, yield_constr, filter, &exp_bits); + constrain_all_to_bits_circuit(builder, yield_constr, filter, &[exp_ge32_bit]); let one = builder.one_extension(); // c[i-1] = 2^(2^i) - 1 @@ -392,7 +392,7 @@ fn constrain_pow_exp_recursively, const D: usize>( yield_constr.constraint(builder, constr4); } -fn constrain_shifted_are_valid_recursively, const D: usize>( +fn constrain_shifted_are_valid_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, @@ -438,7 +438,7 @@ fn constrain_shifted_are_valid_recursively, const D yield_constr.constraint(builder, hi_shifted_is_valid); } -fn eval_rotate_shift_recursively, const D: usize>( +fn eval_rotate_shift_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, @@ -468,8 +468,8 @@ fn eval_rotate_shift_recursively, const D: usize>( let output_lo = lv[COL_ROTATE_SHIFT_OUTPUT_0]; let output_hi = lv[COL_ROTATE_SHIFT_OUTPUT_1]; - constrain_pow_exp_recursively(builder, lv, yield_constr, filter); - constrain_shifted_are_valid_recursively(builder, lv, yield_constr, filter); + constrain_pow_exp_circuit(builder, lv, yield_constr, filter); + constrain_shifted_are_valid_circuit(builder, lv, yield_constr, filter); let base = builder.constant_extension(F::Extension::from_canonical_u64(1u64 << 32)); let lo_shifted = builder.mul_add_extension(lo_shifted_1, base, lo_shifted_0); @@ -500,7 +500,7 @@ fn eval_rotate_shift_recursively, const D: usize>( ) } -pub(crate) fn eval_rotate_left_recursively, const D: usize>( +pub(crate) fn eval_rotate_left_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, @@ -508,7 +508,7 @@ pub(crate) fn eval_rotate_left_recursively, const D let is_rol = lv[IS_ROTATE_LEFT]; let (delta_ge32, lo_shifted_0, lo_shifted_1, hi_shifted_0, hi_shifted_1, output_lo, output_hi) = - eval_rotate_shift_recursively(builder, lv, yield_constr, is_rol); + eval_rotate_shift_circuit(builder, lv, yield_constr, is_rol); let one = builder.one_extension(); let s0 = builder.add_extension(hi_shifted_1, lo_shifted_0); @@ -537,7 +537,7 @@ pub(crate) fn eval_rotate_left_recursively, const D yield_constr.constraint(builder, hi_constr); } -pub(crate) fn eval_rotate_right_recursively, const D: usize>( +pub(crate) fn eval_rotate_right_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, @@ -545,7 +545,7 @@ pub(crate) fn eval_rotate_right_recursively, const let is_ror = lv[IS_ROTATE_RIGHT]; let (delta_ge32, lo_shifted_0, lo_shifted_1, hi_shifted_0, hi_shifted_1, output_lo, output_hi) = - eval_rotate_shift_recursively(builder, lv, yield_constr, is_ror); + eval_rotate_shift_circuit(builder, lv, yield_constr, is_ror); let one = builder.one_extension(); let s0 = builder.add_extension(hi_shifted_1, lo_shifted_0); @@ -574,7 +574,7 @@ pub(crate) fn eval_rotate_right_recursively, const yield_constr.constraint(builder, hi_constr); } -pub(crate) fn eval_shift_left_recursively, const D: usize>( +pub(crate) fn eval_shift_left_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, @@ -582,7 +582,7 @@ pub(crate) fn eval_shift_left_recursively, const D: let is_shl = lv[IS_SHIFT_LEFT]; let (delta_ge32, lo_shifted_0, lo_shifted_1, hi_shifted_0, _hi_shifted_1, output_lo, output_hi) = - eval_rotate_shift_recursively(builder, lv, yield_constr, is_shl); + eval_rotate_shift_circuit(builder, lv, yield_constr, is_shl); let one = builder.one_extension(); let c = builder.sub_extension(one, delta_ge32); @@ -609,7 +609,7 @@ pub(crate) fn eval_shift_left_recursively, const D: yield_constr.constraint(builder, hi_constr); } -pub(crate) fn eval_shift_right_recursively, const D: usize>( +pub(crate) fn eval_shift_right_circuit, const D: usize>( builder: &mut CircuitBuilder, lv: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, @@ -617,7 +617,7 @@ pub(crate) fn eval_shift_right_recursively, const D let is_shr = lv[IS_SHIFT_RIGHT]; let (delta_ge32, _lo_shifted_0, lo_shifted_1, hi_shifted_0, hi_shifted_1, output_lo, output_hi) = - eval_rotate_shift_recursively(builder, lv, yield_constr, is_shr); + eval_rotate_shift_circuit(builder, lv, yield_constr, is_shr); let one = builder.one_extension(); let c = builder.sub_extension(one, delta_ge32); diff --git a/system_zero/src/alu/subtraction.rs b/system_zero/src/alu/subtraction.rs index 20a7f080..2f15da1c 100644 --- a/system_zero/src/alu/subtraction.rs +++ b/system_zero/src/alu/subtraction.rs @@ -45,7 +45,7 @@ pub(crate) fn eval_subtraction>( // checked by boolean::col_bit(0) in the ALU. } -pub(crate) fn eval_subtraction_recursively, const D: usize>( +pub(crate) fn eval_subtraction_circuit, const D: usize>( builder: &mut CircuitBuilder, local_values: &[ExtensionTarget; NUM_COLUMNS], yield_constr: &mut RecursiveConstraintConsumer, diff --git a/system_zero/src/core_registers.rs b/system_zero/src/core_registers.rs index 1f33611a..7f32c0b7 100644 --- a/system_zero/src/core_registers.rs +++ b/system_zero/src/core_registers.rs @@ -62,7 +62,7 @@ pub(crate) fn eval_core_registers>( // TODO constraints for stack etc. } -pub(crate) fn eval_core_registers_recursively, const D: usize>( +pub(crate) fn eval_core_registers_circuit, const D: usize>( builder: &mut CircuitBuilder, vars: StarkEvaluationTargets, yield_constr: &mut RecursiveConstraintConsumer, diff --git a/system_zero/src/lookup.rs b/system_zero/src/lookup.rs index 5a5f0da1..65175a31 100644 --- a/system_zero/src/lookup.rs +++ b/system_zero/src/lookup.rs @@ -121,7 +121,7 @@ pub(crate) fn eval_lookups>( } } -pub(crate) fn eval_lookups_recursively, const D: usize>( +pub(crate) fn eval_lookups_circuit, const D: usize>( builder: &mut CircuitBuilder, vars: StarkEvaluationTargets, yield_constr: &mut RecursiveConstraintConsumer, diff --git a/system_zero/src/permutation_unit.rs b/system_zero/src/permutation_unit.rs index 359ed10b..e2de7d0b 100644 --- a/system_zero/src/permutation_unit.rs +++ b/system_zero/src/permutation_unit.rs @@ -172,7 +172,7 @@ pub(crate) fn eval_permutation_unit( } } -pub(crate) fn eval_permutation_unit_recursively, const D: usize>( +pub(crate) fn eval_permutation_unit_circuit, const D: usize>( builder: &mut CircuitBuilder, vars: StarkEvaluationTargets, yield_constr: &mut RecursiveConstraintConsumer, @@ -187,7 +187,7 @@ pub(crate) fn eval_permutation_unit_recursively, 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, 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, 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, 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, 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 = diff --git a/system_zero/src/system_zero.rs b/system_zero/src/system_zero.rs index adebdf69..85b9a7cf 100644 --- a/system_zero/src/system_zero.rs +++ b/system_zero/src/system_zero.rs @@ -14,15 +14,15 @@ 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, + eval_permutation_unit, eval_permutation_unit_circuit, generate_permutation_unit, }; use crate::public_input_layout::NUM_PUBLIC_INPUTS; use crate::registers::{lookup, NUM_COLUMNS}; @@ -135,16 +135,16 @@ impl, const D: usize> Stark for SystemZero, vars: StarkEvaluationTargets, yield_constr: &mut RecursiveConstraintConsumer, ) { - eval_core_registers_recursively(builder, vars, yield_constr); - eval_alu_recursively(builder, vars, yield_constr); - eval_permutation_unit_recursively(builder, vars, yield_constr); - eval_lookups_recursively(builder, vars, yield_constr); + eval_core_registers_circuit(builder, vars, yield_constr); + eval_alu_circuit(builder, vars, yield_constr); + eval_permutation_unit_circuit(builder, vars, yield_constr); + eval_lookups_circuit(builder, vars, yield_constr); // TODO: Other units } diff --git a/u32/src/gates/add_many_u32.rs b/u32/src/gates/add_many_u32.rs index a96fb5b0..ef79a95f 100644 --- a/u32/src/gates/add_many_u32.rs +++ b/u32/src/gates/add_many_u32.rs @@ -172,7 +172,7 @@ impl, const D: usize> Gate for U32AddManyGate } } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/u32/src/gates/arithmetic_u32.rs b/u32/src/gates/arithmetic_u32.rs index 20697f97..42604bd7 100644 --- a/u32/src/gates/arithmetic_u32.rs +++ b/u32/src/gates/arithmetic_u32.rs @@ -136,7 +136,7 @@ impl, const D: usize> Gate for U32ArithmeticG self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/u32/src/gates/comparison.rs b/u32/src/gates/comparison.rs index 5778600b..a731d91f 100644 --- a/u32/src/gates/comparison.rs +++ b/u32/src/gates/comparison.rs @@ -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, const D: usize> Gate for ComparisonGate self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, @@ -205,9 +205,9 @@ impl, const D: usize> Gate 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, const D: usize> Gate 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); diff --git a/u32/src/gates/range_check_u32.rs b/u32/src/gates/range_check_u32.rs index 5b8b543f..bcc760cd 100644 --- a/u32/src/gates/range_check_u32.rs +++ b/u32/src/gates/range_check_u32.rs @@ -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, const D: usize> Gate for U32RangeCheckG } } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, @@ -112,7 +112,7 @@ impl, const D: usize> Gate 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 { diff --git a/u32/src/gates/subtraction_u32.rs b/u32/src/gates/subtraction_u32.rs index 9e00397c..ee06a164 100644 --- a/u32/src/gates/subtraction_u32.rs +++ b/u32/src/gates/subtraction_u32.rs @@ -132,7 +132,7 @@ impl, const D: usize> Gate for U32Subtraction self.eval_unfiltered_base_batch_packed(vars_base) } - fn eval_unfiltered_recursively( + fn eval_unfiltered_circuit( &self, builder: &mut CircuitBuilder, vars: EvaluationTargets, diff --git a/waksman/src/gates/switch.rs b/waksman/src/gates/switch.rs index b9ac8e70..ce9815d5 100644 --- a/waksman/src/gates/switch.rs +++ b/waksman/src/gates/switch.rs @@ -112,7 +112,7 @@ impl, const D: usize> Gate for SwitchGate, vars: EvaluationTargets, diff --git a/waksman/src/permutation.rs b/waksman/src/permutation.rs index d075b076..907c153f 100644 --- a/waksman/src/permutation.rs +++ b/waksman/src/permutation.rs @@ -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, const D: usize>( +pub fn assert_permutation_circuit, const D: usize>( builder: &mut CircuitBuilder, a: Vec>, b: Vec>, @@ -35,7 +35,7 @@ pub fn assert_permutation, 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, 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, const D: usize>( +fn assert_permutation_2x2_circuit, const D: usize>( builder: &mut CircuitBuilder, a1: Vec, a2: Vec, @@ -62,7 +62,7 @@ fn assert_permutation_2x2, 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, 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, const D: usize>( +fn create_switch_circuit, const D: usize>( builder: &mut CircuitBuilder, a1: Vec, a2: Vec, @@ -104,7 +104,7 @@ fn create_switch, const D: usize>( (switch, c, d) } -fn assert_permutation_recursive, const D: usize>( +fn assert_permutation_helper_circuit, const D: usize>( builder: &mut CircuitBuilder, a: Vec>, b: Vec>, @@ -135,13 +135,15 @@ fn assert_permutation_recursive, 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); @@ -156,8 +158,8 @@ fn assert_permutation_recursive, 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:: { a, @@ -394,7 +396,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::(); let proof = data.prove(pw)?; @@ -424,7 +426,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::(); let proof = data.prove(pw)?; @@ -453,7 +455,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::(); data.prove(pw)?; diff --git a/waksman/src/sorting.rs b/waksman/src/sorting.rs index 1a9805e6..5f44f66d 100644 --- a/waksman/src/sorting.rs +++ b/waksman/src/sorting.rs @@ -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 { is_write: bool, @@ -28,7 +28,7 @@ pub struct MemoryOpTarget { value: Target, } -pub fn assert_permutation_memory_ops, const D: usize>( +pub fn assert_permutation_memory_ops_circuit, const D: usize>( builder: &mut CircuitBuilder, a: &[MemoryOpTarget], b: &[MemoryOpTarget], @@ -42,11 +42,11 @@ pub fn assert_permutation_memory_ops, 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, const D: usize>( +pub fn assert_le_circuit, const D: usize>( builder: &mut CircuitBuilder, lhs: Target, rhs: Target, @@ -62,7 +62,7 @@ pub fn assert_le, 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, const D: usize>( +pub fn sort_memory_ops_circuit, const D: usize>( builder: &mut CircuitBuilder, ops: &[MemoryOpTarget], address_bits: usize, @@ -106,7 +106,7 @@ pub fn sort_memory_ops, 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, 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:: { 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,