From 69a945547a9d9840f3c603f6ef496f7a21add4cb Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Tue, 24 Aug 2021 08:25:11 +0200 Subject: [PATCH 1/3] `route, assert_equal` -> `connect` --- src/gadgets/arithmetic.rs | 4 +-- src/gadgets/arithmetic_extension.rs | 6 ++--- src/gadgets/hash.rs | 4 +-- src/gadgets/insert.rs | 8 +++--- src/gadgets/interpolation.rs | 6 ++--- src/gadgets/random_access.rs | 6 ++--- src/gadgets/range_check.rs | 4 +-- src/gadgets/split_base.rs | 14 +++++------ src/gadgets/split_join.rs | 2 +- src/gates/switch.rs | 4 +-- src/hash/merkle_proofs.rs | 18 +++++++------- src/plonk/circuit_builder.rs | 38 +++++++++++------------------ src/util/reducing.rs | 6 ++--- 13 files changed, 55 insertions(+), 65 deletions(-) diff --git a/src/gadgets/arithmetic.rs b/src/gadgets/arithmetic.rs index fd61804b..960f139f 100644 --- a/src/gadgets/arithmetic.rs +++ b/src/gadgets/arithmetic.rs @@ -116,9 +116,9 @@ impl, const D: usize> CircuitBuilder { } let gate_index = self.add_gate(gate.clone(), vec![]); - self.route(base, Target::wire(gate_index, gate.wire_base())); + self.connect(base, Target::wire(gate_index, gate.wire_base())); exp_bits_vec.iter().enumerate().for_each(|(i, bit)| { - self.route(bit.target, Target::wire(gate_index, gate.wire_power_bit(i))); + self.connect(bit.target, Target::wire(gate_index, gate.wire_power_bit(i))); }); Target::wire(gate_index, gate.wire_output()) diff --git a/src/gadgets/arithmetic_extension.rs b/src/gadgets/arithmetic_extension.rs index e63b520a..def6b4b8 100644 --- a/src/gadgets/arithmetic_extension.rs +++ b/src/gadgets/arithmetic_extension.rs @@ -67,9 +67,9 @@ impl, const D: usize> CircuitBuilder { let wires_addend = ExtensionTarget::from_range(gate, ArithmeticExtensionGate::::wires_ith_addend(i)); - self.route_extension(multiplicand_0, wires_multiplicand_0); - self.route_extension(multiplicand_1, wires_multiplicand_1); - self.route_extension(addend, wires_addend); + self.connect_extension(multiplicand_0, wires_multiplicand_0); + self.connect_extension(multiplicand_1, wires_multiplicand_1); + self.connect_extension(addend, wires_addend); ExtensionTarget::from_range(gate, ArithmeticExtensionGate::::wires_ith_output(i)) } diff --git a/src/gadgets/hash.rs b/src/gadgets/hash.rs index 0326dc64..8bab0b2f 100644 --- a/src/gadgets/hash.rs +++ b/src/gadgets/hash.rs @@ -20,7 +20,7 @@ impl, const D: usize> CircuitBuilder { gate, input: swap_wire, }); - self.route(zero, swap_wire); + self.connect(zero, swap_wire); // Route input wires. for i in 0..12 { @@ -29,7 +29,7 @@ impl, const D: usize> CircuitBuilder { gate, input: in_wire, }); - self.route(inputs[i], in_wire); + self.connect(inputs[i], in_wire); } // Collect output wires. diff --git a/src/gadgets/insert.rs b/src/gadgets/insert.rs index 4018644d..eb2386c7 100644 --- a/src/gadgets/insert.rs +++ b/src/gadgets/insert.rs @@ -17,16 +17,16 @@ impl, const D: usize> CircuitBuilder { let gate_index = self.add_gate(gate.clone(), vec![]); v.iter().enumerate().for_each(|(i, &val)| { - self.route_extension( + self.connect_extension( val, ExtensionTarget::from_range(gate_index, gate.wires_original_list_item(i)), ); }); - self.route( + self.connect( index, Target::wire(gate_index, gate.wires_insertion_index()), ); - self.route_extension( + self.connect_extension( element, ExtensionTarget::from_range(gate_index, gate.wires_element_to_insert()), ); @@ -79,7 +79,7 @@ mod tests { assert_eq!(inserted.len(), purported_inserted.len()); for (x, y) in inserted.into_iter().zip(purported_inserted) { - builder.route_extension(x, y); + builder.connect_extension(x, y); } } diff --git a/src/gadgets/interpolation.rs b/src/gadgets/interpolation.rs index 2175d0ce..f346f2f2 100644 --- a/src/gadgets/interpolation.rs +++ b/src/gadgets/interpolation.rs @@ -15,13 +15,13 @@ impl, const D: usize> CircuitBuilder { let gate = InterpolationGate::new(interpolation_points.len()); let gate_index = self.add_gate(gate.clone(), vec![]); for (i, &(p, v)) in interpolation_points.iter().enumerate() { - self.route(p, Target::wire(gate_index, gate.wire_point(i))); - self.route_extension( + self.connect(p, Target::wire(gate_index, gate.wire_point(i))); + self.connect_extension( v, ExtensionTarget::from_range(gate_index, gate.wires_value(i)), ); } - self.route_extension( + self.connect_extension( evaluation_point, ExtensionTarget::from_range(gate_index, gate.wires_evaluation_point()), ); diff --git a/src/gadgets/random_access.rs b/src/gadgets/random_access.rs index cdc8bdfd..8afec2af 100644 --- a/src/gadgets/random_access.rs +++ b/src/gadgets/random_access.rs @@ -17,16 +17,16 @@ impl, const D: usize> CircuitBuilder { let gate_index = self.add_gate(gate.clone(), vec![]); v.iter().enumerate().for_each(|(i, &val)| { - self.route_extension( + self.connect_extension( val, ExtensionTarget::from_range(gate_index, gate.wires_list_item(i)), ); }); - self.route( + self.connect( access_index, Target::wire(gate_index, gate.wire_access_index()), ); - self.route_extension( + self.connect_extension( claimed_element, ExtensionTarget::from_range(gate_index, gate.wires_claimed_element()), ); diff --git a/src/gadgets/range_check.rs b/src/gadgets/range_check.rs index c878e799..4f3b7d0d 100644 --- a/src/gadgets/range_check.rs +++ b/src/gadgets/range_check.rs @@ -11,7 +11,7 @@ impl, const D: usize> CircuitBuilder { pub fn range_check(&mut self, x: Target, n_log: usize) { let gate = self.add_gate(BaseSumGate::<2>::new(n_log), vec![]); let sum = Target::wire(gate, BaseSumGate::<2>::WIRE_SUM); - self.route(x, sum); + self.connect(x, sum); } /// Returns the first `num_low_bits` little-endian bits of `x`. @@ -37,7 +37,7 @@ impl, const D: usize> CircuitBuilder { let pow2 = self.constant(F::from_canonical_u64(1 << n_log)); let comp_x = self.mul_add(high, pow2, low); - self.assert_equal(x, comp_x); + self.connect(x, comp_x); (low, high) } diff --git a/src/gadgets/split_base.rs b/src/gadgets/split_base.rs index 41ed8799..914269d5 100644 --- a/src/gadgets/split_base.rs +++ b/src/gadgets/split_base.rs @@ -15,7 +15,7 @@ impl, const D: usize> CircuitBuilder { let gate_type = BaseSumGate::::new(num_limbs); let gate = self.add_gate(gate_type.clone(), vec![]); let sum = Target::wire(gate, BaseSumGate::::WIRE_SUM); - self.route(x, sum); + self.connect(x, sum); Target::wires_from_range(gate, gate_type.limbs()) } @@ -41,7 +41,7 @@ impl, const D: usize> CircuitBuilder { .clone() .zip(BaseSumGate::<2>::START_LIMBS..BaseSumGate::<2>::START_LIMBS + num_bits) { - self.route(limb.borrow().target, Target::wire(gate_index, wire)); + self.connect(limb.borrow().target, Target::wire(gate_index, wire)); } self.add_generator(BaseSumGenerator::<2> { @@ -106,10 +106,10 @@ mod tests { let two = builder.two(); let three = builder.constant(F::from_canonical_u64(3)); let five = builder.constant(F::from_canonical_u64(5)); - builder.route(limbs[0], two); - builder.route(limbs[1], three); - builder.route(limbs[2], five); - builder.route(limbs[3], one); + builder.connect(limbs[0], two); + builder.connect(limbs[1], three); + builder.connect(limbs[2], five); + builder.connect(limbs[3], one); builder.assert_leading_zeros(xt, 64 - 9); let data = builder.build(); @@ -143,7 +143,7 @@ mod tests { .iter(), ); - builder.assert_equal(x, y); + builder.connect(x, y); let data = builder.build(); diff --git a/src/gadgets/split_join.rs b/src/gadgets/split_join.rs index fe3d724a..4b6527ca 100644 --- a/src/gadgets/split_join.rs +++ b/src/gadgets/split_join.rs @@ -45,7 +45,7 @@ impl, const D: usize> CircuitBuilder { sum, ); } - self.assert_equal(acc, integer); + self.connect(acc, integer); self.add_generator(WireSplitGenerator { integer, diff --git a/src/gates/switch.rs b/src/gates/switch.rs index 7d99387f..6ef29341 100644 --- a/src/gates/switch.rs +++ b/src/gates/switch.rs @@ -7,7 +7,7 @@ use crate::gates::gate::Gate; use crate::iop::generator::{GeneratedValues, SimpleGenerator, WitnessGenerator}; use crate::iop::target::Target; use crate::iop::wire::Wire; -use crate::iop::witness::PartialWitness; +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}; @@ -210,7 +210,7 @@ impl, const D: usize, const CHUNK_SIZE: usize> SimpleGenerator< deps } - fn run_once(&self, witness: &PartialWitness, out_buffer: &mut GeneratedValues) { + fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) { let local_wire = |input| Wire { gate: self.gate_index, input, diff --git a/src/hash/merkle_proofs.rs b/src/hash/merkle_proofs.rs index cfdef5ff..43cf49e2 100644 --- a/src/hash/merkle_proofs.rs +++ b/src/hash/merkle_proofs.rs @@ -78,7 +78,7 @@ impl, const D: usize> CircuitBuilder { gate, input: swap_wire, }); - self.route(bit.target, swap_wire); + self.connect(bit.target, swap_wire); let input_wires = (0..12) .map(|i| { @@ -90,9 +90,9 @@ impl, const D: usize> CircuitBuilder { .collect::>(); for i in 0..4 { - self.route(state.elements[i], input_wires[i]); - self.route(sibling.elements[i], input_wires[4 + i]); - self.route(zero, input_wires[8 + i]); + self.connect(state.elements[i], input_wires[i]); + self.connect(sibling.elements[i], input_wires[4 + i]); + self.connect(zero, input_wires[8 + i]); } state = HashOutTarget::from_vec( @@ -156,9 +156,9 @@ impl, const D: usize> CircuitBuilder { .collect::>(); for i in 0..4 { - self.route(state.elements[i], input_wires[i]); - self.route(sibling.elements[i], input_wires[4 + i]); - self.route(zero, input_wires[8 + i]); + self.connect(state.elements[i], input_wires[i]); + self.connect(sibling.elements[i], input_wires[4 + i]); + self.connect(zero, input_wires[8 + i]); } state = HashOutTarget::from_vec( @@ -188,13 +188,13 @@ impl, const D: usize> CircuitBuilder { pub fn assert_hashes_equal(&mut self, x: HashOutTarget, y: HashOutTarget) { for i in 0..4 { - self.assert_equal(x.elements[i], y.elements[i]); + self.connect(x.elements[i], y.elements[i]); } } pub fn named_assert_hashes_equal(&mut self, x: HashOutTarget, y: HashOutTarget, name: String) { for i in 0..4 { - self.named_assert_equal( + self.named_connect( x.elements[i], y.elements[i], format!("{}: {}-th hash element", name, i), diff --git a/src/plonk/circuit_builder.rs b/src/plonk/circuit_builder.rs index 56bee0a5..67dc97e5 100644 --- a/src/plonk/circuit_builder.rs +++ b/src/plonk/circuit_builder.rs @@ -173,30 +173,20 @@ impl, const D: usize> CircuitBuilder { ); } - /// Both elements must be routable, otherwise this method will panic. - pub fn route(&mut self, src: Target, dst: Target) { - self.assert_equal(src, dst); - } - - /// Same as `route` with a named copy constraint. - pub fn named_route(&mut self, src: Target, dst: Target, name: String) { - self.named_assert_equal(src, dst, name); - } - - pub fn route_extension(&mut self, src: ExtensionTarget, dst: ExtensionTarget) { + pub fn connect_extension(&mut self, src: ExtensionTarget, dst: ExtensionTarget) { for i in 0..D { - self.route(src.0[i], dst.0[i]); + self.connect(src.0[i], dst.0[i]); } } - pub fn named_route_extension( + pub fn named_connect_extension( &mut self, src: ExtensionTarget, dst: ExtensionTarget, name: String, ) { for i in 0..D { - self.named_route(src.0[i], dst.0[i], format!("{}: limb {}", name, i)); + self.named_connect(src.0[i], dst.0[i], format!("{}: limb {}", name, i)); } } @@ -207,7 +197,7 @@ impl, const D: usize> CircuitBuilder { /// Uses Plonk's permutation argument to require that two elements be equal. /// Both elements must be routable, otherwise this method will panic. - pub fn assert_equal(&mut self, x: Target, y: Target) { + pub fn connect(&mut self, x: Target, y: Target) { assert!( x.is_routable(&self.config), "Tried to route a wire that isn't routable" @@ -221,7 +211,7 @@ impl, const D: usize> CircuitBuilder { } /// Same as `assert_equal` for a named copy constraint. - pub fn named_assert_equal(&mut self, x: Target, y: Target, name: String) { + pub fn named_connect(&mut self, x: Target, y: Target, name: String) { assert!( x.is_routable(&self.config), "Tried to route a wire that isn't routable" @@ -238,12 +228,12 @@ impl, const D: usize> CircuitBuilder { pub fn assert_zero(&mut self, x: Target) { let zero = self.zero(); - self.assert_equal(x, zero); + self.connect(x, zero); } pub fn assert_equal_extension(&mut self, x: ExtensionTarget, y: ExtensionTarget) { for i in 0..D { - self.assert_equal(x.0[i], y.0[i]); + self.connect(x.0[i], y.0[i]); } } @@ -254,8 +244,8 @@ impl, const D: usize> CircuitBuilder { name: String, ) { for i in 0..D { - self.assert_equal(x.0[i], y.0[i]); - self.named_assert_equal(x.0[i], y.0[i], format!("{}: limb {}", name, i)); + self.connect(x.0[i], y.0[i]); + self.named_connect(x.0[i], y.0[i], format!("{}: limb {}", name, i)); } } @@ -554,9 +544,9 @@ impl, const D: usize> CircuitBuilder { ArithmeticExtensionGate::::wires_ith_addend(j), ); - self.route_extension(zero, wires_multiplicand_0); - self.route_extension(zero, wires_multiplicand_1); - self.route_extension(zero, wires_addend); + self.connect_extension(zero, wires_multiplicand_0); + self.connect_extension(zero, wires_multiplicand_1); + self.connect_extension(zero, wires_addend); } } } @@ -583,7 +573,7 @@ impl, const D: usize> CircuitBuilder { .iter() .zip(PublicInputGate::wires_public_inputs_hash()) { - self.route(hash_part, Target::wire(pi_gate, wire)) + self.connect(hash_part, Target::wire(pi_gate, wire)) } info!( diff --git a/src/util/reducing.rs b/src/util/reducing.rs index 1952d8cb..cb232939 100644 --- a/src/util/reducing.rs +++ b/src/util/reducing.rs @@ -119,16 +119,16 @@ impl ReducingFactorTarget { let gate = ReducingGate::new(max_coeffs_len); let gate_index = builder.add_gate(gate.clone(), Vec::new()); - builder.route_extension( + builder.connect_extension( self.base, ExtensionTarget::from_range(gate_index, ReducingGate::::wires_alpha()), ); - builder.route_extension( + builder.connect_extension( acc, ExtensionTarget::from_range(gate_index, ReducingGate::::wires_old_acc()), ); for (&t, c) in chunk.iter().zip(gate.wires_coeffs()) { - builder.route(t, Target::wire(gate_index, c)); + builder.connect(t, Target::wire(gate_index, c)); } acc = ExtensionTarget::from_range(gate_index, ReducingGate::::wires_output()); From 71f64329c755420e44925fa1599cc5c13df62b61 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Tue, 24 Aug 2021 08:30:34 +0200 Subject: [PATCH 2/3] Minor --- src/fri/recursive_verifier.rs | 2 +- src/gadgets/arithmetic_extension.rs | 12 ++++++------ src/gadgets/interpolation.rs | 2 +- src/gadgets/select.rs | 4 ++-- src/plonk/circuit_builder.rs | 20 +------------------- src/plonk/recursive_verifier.rs | 2 +- src/util/reducing.rs | 4 ++-- 7 files changed, 14 insertions(+), 32 deletions(-) diff --git a/src/fri/recursive_verifier.rs b/src/fri/recursive_verifier.rs index 4cfd837a..eb6cdcaa 100644 --- a/src/fri/recursive_verifier.rs +++ b/src/fri/recursive_verifier.rs @@ -380,7 +380,7 @@ impl, const D: usize> CircuitBuilder { "evaluate final polynomial", proof.final_poly.eval_scalar(self, subgroup_x) ); - self.assert_equal_extension(eval, old_eval); + self.connect_extension(eval, old_eval); } } diff --git a/src/gadgets/arithmetic_extension.rs b/src/gadgets/arithmetic_extension.rs index def6b4b8..9f5d7141 100644 --- a/src/gadgets/arithmetic_extension.rs +++ b/src/gadgets/arithmetic_extension.rs @@ -421,7 +421,7 @@ impl, const D: usize> CircuitBuilder { // Enforce that x times its purported inverse equals 1. let y_inv = self.mul_extension(y, inv); - self.assert_equal_extension(y_inv, one); + self.connect_extension(y_inv, one); self.mul_add_extension(x, inv, z) } @@ -535,8 +535,8 @@ mod tests { }; let mul2 = builder.constant_extension(vs.into_iter().product()); - builder.assert_equal_extension(mul0, mul1); - builder.assert_equal_extension(mul1, mul2); + builder.connect_extension(mul0, mul1); + builder.connect_extension(mul1, mul2); let data = builder.build(); let proof = data.prove(pw)?; @@ -563,8 +563,8 @@ mod tests { let zt = builder.constant_extension(z); let comp_zt = builder.div_extension(xt, yt); let comp_zt_unsafe = builder.div_extension(xt, yt); - builder.assert_equal_extension(zt, comp_zt); - builder.assert_equal_extension(zt, comp_zt_unsafe); + builder.connect_extension(zt, comp_zt); + builder.connect_extension(zt, comp_zt_unsafe); let data = builder.build(); let proof = data.prove(pw)?; @@ -594,7 +594,7 @@ mod tests { let zt = builder.constant_ext_algebra(za); let comp_zt = builder.mul_ext_algebra(xt, yt); for i in 0..D { - builder.assert_equal_extension(zt.0[i], comp_zt.0[i]); + builder.connect_extension(zt.0[i], comp_zt.0[i]); } let data = builder.build(); diff --git a/src/gadgets/interpolation.rs b/src/gadgets/interpolation.rs index f346f2f2..3ee0afe6 100644 --- a/src/gadgets/interpolation.rs +++ b/src/gadgets/interpolation.rs @@ -76,7 +76,7 @@ mod tests { let eval = builder.interpolate(&points_target, zt); let true_eval_target = builder.constant_extension(true_eval); - builder.assert_equal_extension(eval, true_eval_target); + builder.connect_extension(eval, true_eval_target); let data = builder.build(); let proof = data.prove(pw)?; diff --git a/src/gadgets/select.rs b/src/gadgets/select.rs index a888d105..c5edbe28 100644 --- a/src/gadgets/select.rs +++ b/src/gadgets/select.rs @@ -68,8 +68,8 @@ mod tests { let should_be_x = builder.select_ext(truet, xt, yt); let should_be_y = builder.select_ext(falset, xt, yt); - builder.assert_equal_extension(should_be_x, xt); - builder.assert_equal_extension(should_be_y, yt); + builder.connect_extension(should_be_x, xt); + builder.connect_extension(should_be_y, yt); let data = builder.build(); let proof = data.prove(pw)?; diff --git a/src/plonk/circuit_builder.rs b/src/plonk/circuit_builder.rs index 67dc97e5..6e73de75 100644 --- a/src/plonk/circuit_builder.rs +++ b/src/plonk/circuit_builder.rs @@ -210,7 +210,7 @@ impl, const D: usize> CircuitBuilder { .push(CopyConstraint::new((x, y), self.context_log.open_stack())); } - /// Same as `assert_equal` for a named copy constraint. + /// Same as connect` for a named copy constraint. pub fn named_connect(&mut self, x: Target, y: Target, name: String) { assert!( x.is_routable(&self.config), @@ -231,24 +231,6 @@ impl, const D: usize> CircuitBuilder { self.connect(x, zero); } - pub fn assert_equal_extension(&mut self, x: ExtensionTarget, y: ExtensionTarget) { - for i in 0..D { - self.connect(x.0[i], y.0[i]); - } - } - - pub fn named_assert_equal_extension( - &mut self, - x: ExtensionTarget, - y: ExtensionTarget, - name: String, - ) { - for i in 0..D { - self.connect(x.0[i], y.0[i]); - self.named_connect(x.0[i], y.0[i], format!("{}: limb {}", name, i)); - } - } - pub fn add_generators(&mut self, generators: Vec>>) { self.generators.extend(generators); } diff --git a/src/plonk/recursive_verifier.rs b/src/plonk/recursive_verifier.rs index 14a60df3..e90bf786 100644 --- a/src/plonk/recursive_verifier.rs +++ b/src/plonk/recursive_verifier.rs @@ -94,7 +94,7 @@ impl, const D: usize> CircuitBuilder { { let recombined_quotient = scale.reduce(chunk, self); let computed_vanishing_poly = self.mul_extension(z_h_zeta, recombined_quotient); - self.named_assert_equal_extension( + self.named_connect_extension( vanishing_polys_zeta[i], computed_vanishing_poly, format!("Vanishing polynomial == Z_H * quotient, challenge {}", i), diff --git a/src/util/reducing.rs b/src/util/reducing.rs index cb232939..40e52e01 100644 --- a/src/util/reducing.rs +++ b/src/util/reducing.rs @@ -213,7 +213,7 @@ mod tests { let vs_t = vs.iter().map(|&v| builder.constant(v)).collect::>(); let circuit_reduce = alpha_t.reduce_base(&vs_t, &mut builder); - builder.assert_equal_extension(manual_reduce, circuit_reduce); + builder.connect_extension(manual_reduce, circuit_reduce); let data = builder.build(); let proof = data.prove(pw)?; @@ -244,7 +244,7 @@ mod tests { .collect::>(); let circuit_reduce = alpha_t.reduce(&vs_t, &mut builder); - builder.assert_equal_extension(manual_reduce, circuit_reduce); + builder.connect_extension(manual_reduce, circuit_reduce); let data = builder.build(); let proof = data.prove(pw)?; From d01d206524c55eddaed4de8b6b74e9ab3e374292 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Tue, 24 Aug 2021 18:20:47 +0200 Subject: [PATCH 3/3] Remove named connects --- src/hash/merkle_proofs.rs | 10 ---------- src/plonk/circuit_builder.rs | 27 --------------------------- src/plonk/recursive_verifier.rs | 6 +----- 3 files changed, 1 insertion(+), 42 deletions(-) diff --git a/src/hash/merkle_proofs.rs b/src/hash/merkle_proofs.rs index 43cf49e2..82f15db0 100644 --- a/src/hash/merkle_proofs.rs +++ b/src/hash/merkle_proofs.rs @@ -191,16 +191,6 @@ impl, const D: usize> CircuitBuilder { self.connect(x.elements[i], y.elements[i]); } } - - pub fn named_assert_hashes_equal(&mut self, x: HashOutTarget, y: HashOutTarget, name: String) { - for i in 0..4 { - self.named_connect( - x.elements[i], - y.elements[i], - format!("{}: {}-th hash element", name, i), - ); - } - } } #[cfg(test)] diff --git a/src/plonk/circuit_builder.rs b/src/plonk/circuit_builder.rs index 6e73de75..7a5b57bc 100644 --- a/src/plonk/circuit_builder.rs +++ b/src/plonk/circuit_builder.rs @@ -179,17 +179,6 @@ impl, const D: usize> CircuitBuilder { } } - pub fn named_connect_extension( - &mut self, - src: ExtensionTarget, - dst: ExtensionTarget, - name: String, - ) { - for i in 0..D { - self.named_connect(src.0[i], dst.0[i], format!("{}: limb {}", name, i)); - } - } - /// Adds a generator which will copy `src` to `dst`. pub fn generate_copy(&mut self, src: Target, dst: Target) { self.add_generator(CopyGenerator { src, dst }); @@ -210,22 +199,6 @@ impl, const D: usize> CircuitBuilder { .push(CopyConstraint::new((x, y), self.context_log.open_stack())); } - /// Same as connect` for a named copy constraint. - pub fn named_connect(&mut self, x: Target, y: Target, name: String) { - assert!( - x.is_routable(&self.config), - "Tried to route a wire that isn't routable" - ); - assert!( - y.is_routable(&self.config), - "Tried to route a wire that isn't routable" - ); - self.copy_constraints.push(CopyConstraint::new( - (x, y), - format!("{} > {}", self.context_log.open_stack(), name), - )); - } - pub fn assert_zero(&mut self, x: Target) { let zero = self.zero(); self.connect(x, zero); diff --git a/src/plonk/recursive_verifier.rs b/src/plonk/recursive_verifier.rs index e90bf786..f9e864b3 100644 --- a/src/plonk/recursive_verifier.rs +++ b/src/plonk/recursive_verifier.rs @@ -94,11 +94,7 @@ impl, const D: usize> CircuitBuilder { { let recombined_quotient = scale.reduce(chunk, self); let computed_vanishing_poly = self.mul_extension(z_h_zeta, recombined_quotient); - self.named_connect_extension( - vanishing_polys_zeta[i], - computed_vanishing_poly, - format!("Vanishing polynomial == Z_H * quotient, challenge {}", i), - ); + self.connect_extension(vanishing_polys_zeta[i], computed_vanishing_poly); } });