From 1035438df46df7dcb3d855a907763016a81fd1ba Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Fri, 21 Jan 2022 16:10:25 -0800 Subject: [PATCH] updated for changes in main --- plonky2/src/curve/ecdsa.rs | 29 ++++--- plonky2/src/gadgets/arithmetic_u32.rs | 14 +++- plonky2/src/gadgets/biguint.rs | 2 +- plonky2/src/gadgets/ecdsa.rs | 21 ++--- plonky2/src/gadgets/mod.rs | 1 - plonky2/src/gadgets/nonnative.rs | 26 +++++-- plonky2/src/gadgets/range_check.rs | 2 + plonky2/src/gates/add_many_u32.rs | 31 +++++--- plonky2/src/gates/mod.rs | 2 - plonky2/src/gates/range_check_u32.rs | 31 +++++--- plonky2/src/iop/generator.rs | 9 +-- plonky2/src/plonk/circuit_builder.rs | 106 -------------------------- 12 files changed, 101 insertions(+), 173 deletions(-) diff --git a/plonky2/src/curve/ecdsa.rs b/plonky2/src/curve/ecdsa.rs index 82eeba08..cce83d4c 100644 --- a/plonky2/src/curve/ecdsa.rs +++ b/plonky2/src/curve/ecdsa.rs @@ -2,8 +2,10 @@ use itertools::{unfold, Itertools}; use num::BigUint; use crate::curve::curve_types::{AffinePoint, Curve, CurveScalar}; -use crate::field::field_types::{Field, RichField}; -use crate::hash::hashing::hash_n_to_1; +use crate::field::field_types::Field; +use crate::hash::hash_types::RichField; +use crate::hash::hashing::{hash_n_to_m, PlonkyPermutation}; +use crate::hash::poseidon::PoseidonPermutation; pub struct ECDSASignature { pub r: C::ScalarField, @@ -21,8 +23,8 @@ pub fn scalar_to_base(x: C::ScalarField) -> C::BaseField { C::BaseField::from_biguint(x.to_biguint()) } -pub fn hash_to_bits(x: F, num_bits: usize) -> Vec { - let hashed = hash_n_to_1(vec![x], true); +pub fn hash_to_bits>(x: F, num_bits: usize) -> Vec { + let hashed = hash_n_to_m::(&vec![x], 1, true)[0]; let mut val = hashed.to_canonical_u64(); unfold((), move |_| { @@ -34,21 +36,26 @@ pub fn hash_to_bits(x: F, num_bits: usize) -> Vec { .collect() } -pub fn hash_to_scalar(x: F, num_bits: usize) -> C::ScalarField { - let h_bits = hash_to_bits(x, num_bits); +pub fn hash_to_scalar>( + x: F, + num_bits: usize, +) -> C::ScalarField { + let h_bits = hash_to_bits::(x, num_bits); let h_vals: Vec<_> = h_bits .iter() .chunks(32) .into_iter() .map(|chunk| { - chunk.enumerate() - .fold(0u32, |acc, (pow, &bit)| acc + (bit as u32) * (2 << pow)) - }).collect(); + chunk + .enumerate() + .fold(0u32, |acc, (pow, &bit)| acc + (bit as u32) * (2 << pow)) + }) + .collect(); C::ScalarField::from_biguint(BigUint::new(h_vals)) } pub fn sign_message(msg: F, sk: ECDSASecretKey) -> ECDSASignature { - let h = hash_to_scalar::(msg, 256); + let h = hash_to_scalar::(msg, 256); let k = C::ScalarField::rand(); let rr = (CurveScalar(k) * C::GENERATOR_PROJECTIVE).to_affine(); @@ -65,7 +72,7 @@ pub fn verify_message( ) -> bool { let ECDSASignature { r, s } = sig; - let h = hash_to_scalar::(msg, 256); + let h = hash_to_scalar::(msg, 256); let c = s.inverse(); let u1 = h * c; diff --git a/plonky2/src/gadgets/arithmetic_u32.rs b/plonky2/src/gadgets/arithmetic_u32.rs index 9bf78d44..8da01dc1 100644 --- a/plonky2/src/gadgets/arithmetic_u32.rs +++ b/plonky2/src/gadgets/arithmetic_u32.rs @@ -1,8 +1,12 @@ +use std::marker::PhantomData; + use plonky2_field::extension_field::Extendable; +use crate::gates::add_many_u32::U32AddManyGate; use crate::gates::arithmetic_u32::U32ArithmeticGate; use crate::gates::subtraction_u32::U32SubtractionGate; use crate::hash::hash_types::RichField; +use crate::iop::generator::{GeneratedValues, SimpleGenerator}; use crate::iop::target::Target; use crate::iop::witness::{PartitionWitness, Witness}; use crate::plonk::circuit_builder::CircuitBuilder; @@ -243,16 +247,18 @@ mod tests { use anyhow::Result; use rand::{thread_rng, Rng}; - use crate::field::goldilocks_field::GoldilocksField; use crate::iop::witness::PartialWitness; use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; + use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; use crate::plonk::verifier::verify; #[test] pub fn test_add_many_u32s() -> Result<()> { - type F = GoldilocksField; - const D: usize = 4; + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + const NUM_ADDENDS: usize = 15; let config = CircuitConfig::standard_recursion_config(); @@ -276,7 +282,7 @@ mod tests { builder.connect_u32(result_low, expected_low); builder.connect_u32(result_high, expected_high); - let data = builder.build(); + let data = builder.build::(); let proof = data.prove(pw).unwrap(); verify(proof, &data.verifier_only, &data.common) } diff --git a/plonky2/src/gadgets/biguint.rs b/plonky2/src/gadgets/biguint.rs index 4f9e1574..51cfcc06 100644 --- a/plonky2/src/gadgets/biguint.rs +++ b/plonky2/src/gadgets/biguint.rs @@ -1,6 +1,6 @@ use std::marker::PhantomData; -use num::{BigUint, Integer}; +use num::{BigUint, FromPrimitive, Integer, Zero}; use plonky2_field::extension_field::Extendable; use crate::gadgets::arithmetic_u32::U32Target; diff --git a/plonky2/src/gadgets/ecdsa.rs b/plonky2/src/gadgets/ecdsa.rs index 03a3807d..cc787eb1 100644 --- a/plonky2/src/gadgets/ecdsa.rs +++ b/plonky2/src/gadgets/ecdsa.rs @@ -2,11 +2,12 @@ use std::marker::PhantomData; use crate::curve::curve_types::Curve; use crate::field::extension_field::Extendable; -use crate::field::field_types::RichField; use crate::gadgets::arithmetic_u32::U32Target; use crate::gadgets::biguint::BigUintTarget; use crate::gadgets::curve::AffinePointTarget; use crate::gadgets::nonnative::NonNativeTarget; +use crate::hash::hash_types::RichField; +use crate::hash::poseidon::PoseidonHash; use crate::iop::target::{BoolTarget, Target}; use crate::plonk::circuit_builder::CircuitBuilder; @@ -21,7 +22,7 @@ pub struct ECDSASignatureTarget { impl, const D: usize> CircuitBuilder { pub fn hash_to_bits(&mut self, x: Target, num_bits: usize) -> Vec { let inputs = vec![x]; - let hashed = self.hash_n_to_m(inputs, 1, true)[0]; + let hashed = self.hash_n_to_m::(inputs, 1, true)[0]; self.split_le(hashed, num_bits) } @@ -82,20 +83,22 @@ mod tests { use crate::curve::ecdsa::{sign_message, ECDSAPublicKey, ECDSASecretKey, ECDSASignature}; use crate::curve::secp256k1::Secp256K1; use crate::field::field_types::Field; - use crate::field::goldilocks_field::GoldilocksField; use crate::field::secp256k1_scalar::Secp256K1Scalar; use crate::gadgets::ecdsa::{ECDSAPublicKeyTarget, ECDSASignatureTarget}; use crate::iop::witness::PartialWitness; use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; + use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; use crate::plonk::verifier::verify; #[test] #[ignore] fn test_ecdsa_circuit() -> Result<()> { - type F = GoldilocksField; - const D: usize = 4; - type C = Secp256K1; + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + type Curve = Secp256K1; let config = CircuitConfig::standard_ecc_config(); @@ -105,8 +108,8 @@ mod tests { let msg = F::rand(); let msg_target = builder.constant(msg); - let sk = ECDSASecretKey::(Secp256K1Scalar::rand()); - let pk = ECDSAPublicKey((CurveScalar(sk.0) * C::GENERATOR_PROJECTIVE).to_affine()); + let sk = ECDSASecretKey::(Secp256K1Scalar::rand()); + let pk = ECDSAPublicKey((CurveScalar(sk.0) * Curve::GENERATOR_PROJECTIVE).to_affine()); let pk_target = ECDSAPublicKeyTarget(builder.constant_affine_point(pk.0)); @@ -122,7 +125,7 @@ mod tests { builder.verify_message(msg_target, sig_target, pk_target); - let data = builder.build(); + let data = builder.build::(); let proof = data.prove(pw).unwrap(); verify(proof, &data.verifier_only, &data.common) } diff --git a/plonky2/src/gadgets/mod.rs b/plonky2/src/gadgets/mod.rs index 5dacdb51..ec4d1263 100644 --- a/plonky2/src/gadgets/mod.rs +++ b/plonky2/src/gadgets/mod.rs @@ -2,7 +2,6 @@ pub mod arithmetic; pub mod arithmetic_extension; pub mod arithmetic_u32; pub mod biguint; -pub mod binary_arithmetic; pub mod curve; pub mod ecdsa; pub mod hash; diff --git a/plonky2/src/gadgets/nonnative.rs b/plonky2/src/gadgets/nonnative.rs index 2c556616..998ce628 100644 --- a/plonky2/src/gadgets/nonnative.rs +++ b/plonky2/src/gadgets/nonnative.rs @@ -1,12 +1,14 @@ use std::marker::PhantomData; -use num::{BigUint, Zero}; +use num::{BigUint, Integer, One, Zero}; use plonky2_field::{extension_field::Extendable, field_types::Field}; use plonky2_util::ceil_div_usize; use crate::gadgets::arithmetic_u32::U32Target; -use crate::field::field_types::RichField; -use crate::gadgets::binary_arithmetic::BinaryTarget; +use crate::gadgets::biguint::BigUintTarget; +use crate::hash::hash_types::RichField; +use crate::iop::generator::{GeneratedValues, SimpleGenerator}; +use crate::iop::target::{BoolTarget, Target}; use crate::iop::witness::{PartitionWitness, Witness}; use crate::plonk::circuit_builder::CircuitBuilder; @@ -514,6 +516,7 @@ mod tests { const D: usize = 2; type C = PoseidonGoldilocksConfig; type F = >::F; + let x_ff = FF::rand(); let y_ff = FF::rand(); let sum_ff = x_ff + y_ff; @@ -537,6 +540,10 @@ mod tests { #[test] fn test_nonnative_many_adds() -> Result<()> { type FF = Secp256K1Base; + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + let a_ff = FF::rand(); let b_ff = FF::rand(); let c_ff = FF::rand(); @@ -549,7 +556,7 @@ mod tests { let config = CircuitConfig::standard_ecc_config(); let pw = PartialWitness::new(); - let mut builder = CircuitBuilder::::new(config); + let mut builder = CircuitBuilder::::new(config); let a = builder.constant_nonnative(a_ff); let b = builder.constant_nonnative(b_ff); @@ -565,7 +572,7 @@ mod tests { let sum_expected = builder.constant_nonnative(sum_ff); builder.connect_nonnative(&sum, &sum_expected); - let data = builder.build(); + let data = builder.build::(); let proof = data.prove(pw).unwrap(); verify(proof, &data.verifier_only, &data.common) } @@ -576,6 +583,7 @@ mod tests { const D: usize = 2; type C = PoseidonGoldilocksConfig; type F = >::F; + let x_ff = FF::rand(); let mut y_ff = FF::rand(); while y_ff.to_biguint() > x_ff.to_biguint() { @@ -627,11 +635,13 @@ mod tests { fn test_nonnative_many_muls_helper(num: usize) { type FF = Secp256K1Base; + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; - type F = GoldilocksField; let config = CircuitConfig::standard_ecc_config(); - let mut unop_builder = CircuitBuilder::::new(config.clone()); - let mut op_builder = CircuitBuilder::::new(config); + let mut unop_builder = CircuitBuilder::::new(config.clone()); + let mut op_builder = CircuitBuilder::::new(config); let ffs: Vec<_> = (0..num).map(|_| FF::rand()).collect(); diff --git a/plonky2/src/gadgets/range_check.rs b/plonky2/src/gadgets/range_check.rs index 5a90afd0..0776fc68 100644 --- a/plonky2/src/gadgets/range_check.rs +++ b/plonky2/src/gadgets/range_check.rs @@ -1,5 +1,7 @@ use plonky2_field::extension_field::Extendable; +use crate::gadgets::arithmetic_u32::U32Target; +use crate::gates::range_check_u32::U32RangeCheckGate; use crate::hash::hash_types::RichField; use crate::iop::generator::{GeneratedValues, SimpleGenerator}; use crate::iop::target::{BoolTarget, Target}; diff --git a/plonky2/src/gates/add_many_u32.rs b/plonky2/src/gates/add_many_u32.rs index 9f67c827..4f9c4293 100644 --- a/plonky2/src/gates/add_many_u32.rs +++ b/plonky2/src/gates/add_many_u32.rs @@ -1,11 +1,14 @@ use std::marker::PhantomData; use itertools::unfold; +use plonky2_util::ceil_div_usize; -use crate::field::extension_field::target::ExtensionTarget; use crate::field::extension_field::Extendable; -use crate::field::field_types::{Field, RichField}; +use crate::field::field_types::Field; use crate::gates::gate::Gate; +use crate::gates::util::StridedConstraintConsumer; +use crate::hash::hash_types::RichField; +use crate::iop::ext_target::ExtensionTarget; use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator}; use crate::iop::target::Target; use crate::iop::wire::Wire; @@ -13,7 +16,6 @@ use crate::iop::witness::{PartitionWitness, Witness}; use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase}; -use crate::util::ceil_div_usize; const LOG2_MAX_NUM_ADDENDS: usize = 4; const MAX_NUM_ADDENDS: usize = 16; @@ -128,8 +130,11 @@ impl, const D: usize> Gate for U32AddManyGate constraints } - fn eval_unfiltered_base(&self, vars: EvaluationVarsBase) -> Vec { - let mut constraints = Vec::with_capacity(self.num_constraints()); + fn eval_unfiltered_base_one( + &self, + vars: EvaluationVarsBase, + mut yield_constr: StridedConstraintConsumer, + ) { for i in 0..self.num_ops { let addends: Vec = (0..self.num_addends) .map(|j| vars.local_wires[self.wire_ith_op_jth_addend(i, j)]) @@ -144,7 +149,7 @@ impl, const D: usize> Gate for U32AddManyGate let base = F::from_canonical_u64(1 << 32u64); let combined_output = output_carry * base + output_result; - constraints.push(combined_output - computed_output); + yield_constr.one(combined_output - computed_output); let mut combined_result_limbs = F::ZERO; let mut combined_carry_limbs = F::ZERO; @@ -155,7 +160,7 @@ impl, const D: usize> Gate for U32AddManyGate let product = (0..max_limb) .map(|x| this_limb - F::from_canonical_usize(x)) .product(); - constraints.push(product); + yield_constr.one(product); if j < Self::num_result_limbs() { combined_result_limbs = base * combined_result_limbs + this_limb; @@ -163,11 +168,9 @@ impl, const D: usize> Gate for U32AddManyGate combined_carry_limbs = base * combined_carry_limbs + this_limb; } } - constraints.push(combined_result_limbs - output_result); - constraints.push(combined_carry_limbs - output_carry); + yield_constr.one(combined_result_limbs - output_result); + yield_constr.one(combined_carry_limbs - output_carry); } - - constraints } fn eval_unfiltered_recursively( @@ -355,6 +358,7 @@ mod tests { use crate::gates::gate::Gate; use crate::gates::gate_testing::{test_eval_fns, test_low_degree}; use crate::hash::hash_types::HashOut; + use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; use crate::plonk::vars::EvaluationVars; #[test] @@ -368,7 +372,10 @@ mod tests { #[test] fn eval_fns() -> Result<()> { - test_eval_fns::(U32AddManyGate:: { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + test_eval_fns::(U32AddManyGate:: { num_addends: 4, num_ops: 3, _phantom: PhantomData, diff --git a/plonky2/src/gates/mod.rs b/plonky2/src/gates/mod.rs index 163a7dac..18e3e99b 100644 --- a/plonky2/src/gates/mod.rs +++ b/plonky2/src/gates/mod.rs @@ -7,8 +7,6 @@ pub mod arithmetic_extension; pub mod arithmetic_u32; pub mod assert_le; pub mod base_sum; -pub mod binary_arithmetic; -pub mod binary_subtraction; pub mod comparison; pub mod constant; pub mod exponentiation; diff --git a/plonky2/src/gates/range_check_u32.rs b/plonky2/src/gates/range_check_u32.rs index 83cdb223..0e73990d 100644 --- a/plonky2/src/gates/range_check_u32.rs +++ b/plonky2/src/gates/range_check_u32.rs @@ -1,16 +1,19 @@ use std::marker::PhantomData; -use crate::field::extension_field::target::ExtensionTarget; +use plonky2_util::ceil_div_usize; + use crate::field::extension_field::Extendable; -use crate::field::field_types::{Field, RichField}; +use crate::field::field_types::Field; use crate::gates::gate::Gate; +use crate::gates::util::StridedConstraintConsumer; +use crate::hash::hash_types::RichField; +use crate::iop::ext_target::ExtensionTarget; use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator}; use crate::iop::target::Target; 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::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase}; -use crate::util::ceil_div_usize; /// A gate which can decompose a number into base B little-endian limbs. #[derive(Copy, Clone, Debug)] @@ -73,9 +76,11 @@ impl, const D: usize> Gate for U32RangeCheckG constraints } - fn eval_unfiltered_base(&self, vars: EvaluationVarsBase) -> Vec { - let mut constraints = Vec::with_capacity(self.num_constraints()); - + fn eval_unfiltered_base_one( + &self, + vars: EvaluationVarsBase, + mut yield_constr: StridedConstraintConsumer, + ) { let base = F::from_canonical_usize(Self::BASE); for i in 0..self.num_input_limbs { let input_limb = vars.local_wires[self.wire_ith_input_limb(i)]; @@ -84,17 +89,15 @@ impl, const D: usize> Gate for U32RangeCheckG .collect(); let computed_sum = reduce_with_powers(&aux_limbs, base); - constraints.push(computed_sum - input_limb); + yield_constr.one(computed_sum - input_limb); for aux_limb in aux_limbs { - constraints.push( + yield_constr.one( (0..Self::BASE) .map(|i| aux_limb - F::from_canonical_usize(i)) .product(), ); } } - - constraints } fn eval_unfiltered_recursively( @@ -217,6 +220,7 @@ mod tests { use anyhow::Result; use itertools::unfold; + use plonky2_util::ceil_div_usize; use rand::Rng; use crate::field::extension_field::quartic::QuarticExtension; @@ -226,8 +230,8 @@ mod tests { use crate::gates::gate_testing::{test_eval_fns, test_low_degree}; use crate::gates::range_check_u32::U32RangeCheckGate; use crate::hash::hash_types::HashOut; + use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; use crate::plonk::vars::EvaluationVars; - use crate::util::ceil_div_usize; #[test] fn low_degree() { @@ -236,7 +240,10 @@ mod tests { #[test] fn eval_fns() -> Result<()> { - test_eval_fns::(U32RangeCheckGate::new(8)) + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + test_eval_fns::(U32RangeCheckGate::new(8)) } fn test_gate_constraint(input_limbs: Vec) { diff --git a/plonky2/src/iop/generator.rs b/plonky2/src/iop/generator.rs index 5f8b8a5f..5d36ed1d 100644 --- a/plonky2/src/iop/generator.rs +++ b/plonky2/src/iop/generator.rs @@ -1,17 +1,16 @@ use std::fmt::Debug; use std::marker::PhantomData; -use num::BigUint; +use num::{BigUint, FromPrimitive, Integer, Zero}; use plonky2_field::extension_field::{Extendable, FieldExtension}; use plonky2_field::field_types::Field; use crate::gadgets::arithmetic_u32::U32Target; use crate::gadgets::biguint::BigUintTarget; -use crate::gadgets::binary_arithmetic::BinaryTarget; use crate::gadgets::nonnative::NonNativeTarget; use crate::hash::hash_types::{HashOut, HashOutTarget, RichField}; use crate::iop::ext_target::ExtensionTarget; -use crate::iop::target::Target; +use crate::iop::target::{BoolTarget, Target}; use crate::iop::wire::Wire; use crate::iop::witness::{PartialWitness, PartitionWitness, Witness}; use crate::plonk::circuit_data::{CommonCircuitData, ProverOnlyCircuitData}; @@ -170,10 +169,6 @@ impl GeneratedValues { self.set_target(target.0, F::from_canonical_u32(value)) } - pub fn set_binary_target(&mut self, target: BinaryTarget, value: F) { - self.set_target(target.0, value) - } - pub fn set_biguint_target(&mut self, target: BigUintTarget, value: BigUint) { let base = BigUint::from_u64(1 << 32).unwrap(); let mut limbs = Vec::new(); diff --git a/plonky2/src/plonk/circuit_builder.rs b/plonky2/src/plonk/circuit_builder.rs index 38091bc9..33c88950 100644 --- a/plonky2/src/plonk/circuit_builder.rs +++ b/plonky2/src/plonk/circuit_builder.rs @@ -19,8 +19,6 @@ use crate::gadgets::polynomial::PolynomialCoeffsExtTarget; use crate::gates::arithmetic_base::ArithmeticGate; use crate::gates::arithmetic_extension::ArithmeticExtensionGate; use crate::gates::arithmetic_u32::U32ArithmeticGate; -use crate::gates::binary_arithmetic::BinaryArithmeticGate; -use crate::gates::binary_subtraction::BinarySubtractionGate; use crate::gates::constant::ConstantGate; use crate::gates::gate::{Gate, GateInstance, GateRef, PrefixedGate}; use crate::gates::gate_tree::Tree; @@ -354,11 +352,6 @@ impl, const D: usize> CircuitBuilder { U32Target(self.constant(F::from_canonical_u32(c))) } - /// Returns a BinaryTarget for the value `c`, which is assumed to be at most BITS bits. - pub fn constant_binary(&mut self, c: F) -> BinaryTarget { - BinaryTarget(self.constant(c)) - } - /// If the given target is a constant (i.e. it was created by the `constant(F)` method), returns /// its constant value. Otherwise, returns `None`. pub fn target_as_constant(&self, target: Target) -> Option { @@ -838,11 +831,6 @@ pub struct BatchedGates, const D: usize> { /// The `U32SubtractionGate` currently being filled (so new u32 subtraction operations will be added to this gate before creating a new one) pub(crate) current_u32_subtraction_gate: Option<(usize, usize)>, - /// A map `b -> (g, i)` from `b` bits to an available `BinaryArithmeticGate` for number of bits `b`. - pub(crate) free_binary_arithmetic_gate: HashMap, - /// A map `b -> (g, i)` from `b` bits to an available `BinarySubtractionGate` for number of bits `b`. - pub(crate) free_binary_subtraction_gate: HashMap, - /// An available `ConstantGate` instance, if any. pub(crate) free_constant: Option<(usize, usize)>, } @@ -858,8 +846,6 @@ impl, const D: usize> BatchedGates { free_u32_add_many: HashMap::new(), current_u32_arithmetic_gate: None, current_u32_subtraction_gate: None, - free_binary_arithmetic_gate: HashMap::new(), - free_binary_subtraction_gate: HashMap::new(), free_constant: None, } } @@ -1085,66 +1071,6 @@ impl, const D: usize> CircuitBuilder { (gate_index, copy) } - /// Finds the last available binary arithmetic with the given `bits` or add one if there aren't any. - /// Returns `(g,i)` such that there is a binary arithmetic for the given `bits` at index - /// `g` and the gate's `i`-th copy is available. - pub(crate) fn find_binary_arithmetic_gate(&mut self) -> (usize, usize) { - let (gate, i) = self - .batched_gates - .free_binary_arithmetic_gate - .get(&BITS) - .copied() - .unwrap_or_else(|| { - let gate = self.add_gate( - BinaryArithmeticGate::::new_from_config(&self.config), - vec![], - ); - (gate, 0) - }); - - // Update `free_binary_arithmetic` with new values. - if i + 1 < BinaryArithmeticGate::::new_from_config(&self.config).num_ops { - self.batched_gates - .free_binary_arithmetic_gate - .insert(BITS, (gate, i + 1)); - } else { - self.batched_gates.free_binary_arithmetic_gate.remove(&BITS); - } - - (gate, i) - } - - /// Finds the last available binary subtraction with the given `bits` or add one if there aren't any. - /// Returns `(g,i)` such that there is a binary subtraction for the given `bits` at index - /// `g` and the gate's `i`-th copy is available. - pub(crate) fn find_binary_subtraction_gate(&mut self) -> (usize, usize) { - let (gate, i) = self - .batched_gates - .free_binary_subtraction_gate - .get(&BITS) - .copied() - .unwrap_or_else(|| { - let gate = self.add_gate( - BinarySubtractionGate::::new_from_config(&self.config), - vec![], - ); - (gate, 0) - }); - - // Update `free_binary_subtraction` with new values. - if i + 1 < BinarySubtractionGate::::new_from_config(&self.config).num_ops { - self.batched_gates - .free_binary_subtraction_gate - .insert(BITS, (gate, i + 1)); - } else { - self.batched_gates - .free_binary_subtraction_gate - .remove(&BITS); - } - - (gate, i) - } - /// Returns the gate index and copy index of a free `ConstantGate` slot, potentially adding a /// new `ConstantGate` if needed. fn constant_gate_instance(&mut self) -> (usize, usize) { @@ -1301,36 +1227,6 @@ impl, const D: usize> CircuitBuilder { } } - /// Fill the remaining unused binary arithmetic operations with zeros, so that all - /// `BinaryArithmeticGenerator`s are run. - fn fill_binary_arithmetic_gates(&mut self) { - let zero = self.zero_binary::<30>(); - if let Some(&(_, i)) = self.batched_gates.free_binary_arithmetic_gate.get(&30) { - let max_copies = - BinaryArithmeticGate::::new_from_config(&self.config).num_ops; - for _ in i..max_copies { - let dummy = self.add_virtual_binary_target(); - self.mul_add_binary(dummy, dummy, dummy); - self.connect_binary(dummy, zero); - } - } - } - - /// Fill the remaining unused binary subtraction operations with zeros, so that all - /// `BinarySubtractionGenerator`s are run. - fn fill_binary_subtraction_gates(&mut self) { - let zero = self.zero_binary::<30>(); - if let Some(&(_, i)) = self.batched_gates.free_binary_subtraction_gate.get(&30) { - let max_copies = - BinarySubtractionGate::::new_from_config(&self.config).num_ops; - for _ in i..max_copies { - let dummy = self.add_virtual_binary_target(); - self.sub_binary(dummy, dummy, dummy); - self.connect_binary(dummy, zero); - } - } - } - fn fill_batched_gates(&mut self) { self.fill_arithmetic_gates(); self.fill_base_arithmetic_gates(); @@ -1340,7 +1236,5 @@ impl, const D: usize> CircuitBuilder { self.fill_u32_add_many_gates(); self.fill_u32_arithmetic_gates(); self.fill_u32_subtraction_gates(); - self.fill_binary_arithmetic_gates(); - self.fill_binary_subtraction_gates(); } }