From 9552fcc66b948b9ea7ed7b6cc4f74276fdff78e2 Mon Sep 17 00:00:00 2001 From: Ahmad Date: Tue, 20 May 2025 14:42:15 +1000 Subject: [PATCH] Fix build --- Cargo.toml | 4 ++-- src/gadgets/arithmetic_u32.rs | 7 ++++--- src/gadgets/multiple_comparison.rs | 4 ++-- src/gates/add_many_u32.rs | 17 ++++++++++------- src/gates/arithmetic_u32.rs | 13 ++++++++----- src/gates/comparison.rs | 26 +++++++++++++++----------- src/gates/range_check_u32.rs | 13 ++++++++----- src/gates/subtraction_u32.rs | 11 +++++++---- src/witness.rs | 11 ++++++----- 9 files changed, 62 insertions(+), 44 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 009e968..31c2d49 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,8 +10,8 @@ edition = "2021" anyhow = { version = "1.0.40", default-features = false } itertools = { version = "0.10.0", default-features = false } num = { version = "0.4", default-features = false } -plonky2 = "0.1.4" +plonky2 = { git = "https://github.com/0xPolygonZero/plonky2" } [dev-dependencies] rand = { version = "0.8.4", default-features = false, features = ["getrandom"] } -plonky2 = "0.1.4" +plonky2 = { git = "https://github.com/0xPolygonZero/plonky2" } diff --git a/src/gadgets/arithmetic_u32.rs b/src/gadgets/arithmetic_u32.rs index 8d00a81..d4202b5 100644 --- a/src/gadgets/arithmetic_u32.rs +++ b/src/gadgets/arithmetic_u32.rs @@ -1,6 +1,7 @@ use alloc::string::{String, ToString}; use alloc::vec; use alloc::vec::Vec; +use anyhow::Result; use core::marker::PhantomData; use plonky2::plonk::circuit_data::CommonCircuitData; use plonky2::util::serialization::{Buffer, IoResult, Read, Write}; @@ -271,14 +272,14 @@ impl, const D: usize> SimpleGenerator vec![self.x] } - fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) { + fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) -> Result<()> { let x = witness.get_target(self.x); let x_u64 = x.to_canonical_u64(); let low = x_u64 as u32; let high = (x_u64 >> 32) as u32; - out_buffer.set_u32_target(self.low, low); - out_buffer.set_u32_target(self.high, high); + out_buffer.set_u32_target(self.low, low)?; + out_buffer.set_u32_target(self.high, high) } } diff --git a/src/gadgets/multiple_comparison.rs b/src/gadgets/multiple_comparison.rs index 8d82c29..c642694 100644 --- a/src/gadgets/multiple_comparison.rs +++ b/src/gadgets/multiple_comparison.rs @@ -1,11 +1,11 @@ use alloc::vec; use alloc::vec::Vec; +use num::integer::div_ceil; use plonky2::field::extension::Extendable; use plonky2::hash::hash_types::RichField; use plonky2::iop::target::{BoolTarget, Target}; use plonky2::plonk::circuit_builder::CircuitBuilder; -use plonky2::util::ceil_div_usize; use crate::gadgets::arithmetic_u32::U32Target; use crate::gates::comparison::ComparisonGate; @@ -26,7 +26,7 @@ pub fn list_le_circuit, const D: usize>( let n = a.len(); let chunk_bits = 2; - let num_chunks = ceil_div_usize(num_bits, chunk_bits); + let num_chunks = div_ceil(num_bits, chunk_bits); let one = builder.one(); let mut result = one; diff --git a/src/gates/add_many_u32.rs b/src/gates/add_many_u32.rs index d357e11..dd156fc 100644 --- a/src/gates/add_many_u32.rs +++ b/src/gates/add_many_u32.rs @@ -1,6 +1,8 @@ use alloc::format; use alloc::string::{String, ToString}; use alloc::vec::Vec; +use anyhow::Result; +use num::integer::div_ceil; use core::marker::PhantomData; use plonky2::util::serialization::{Buffer, IoResult, Read, Write}; @@ -18,7 +20,6 @@ use plonky2::iop::witness::{PartitionWitness, Witness, WitnessWrite}; use plonky2::plonk::circuit_builder::CircuitBuilder; use plonky2::plonk::circuit_data::{CircuitConfig, CommonCircuitData}; use plonky2::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase}; -use plonky2::util::ceil_div_usize; const LOG2_MAX_NUM_ADDENDS: usize = 4; const MAX_NUM_ADDENDS: usize = 16; @@ -70,10 +71,10 @@ impl, const D: usize> U32AddManyGate { 2 } pub fn num_result_limbs() -> usize { - ceil_div_usize(32, Self::limb_bits()) + div_ceil(32, Self::limb_bits()) } pub fn num_carry_limbs() -> usize { - ceil_div_usize(LOG2_MAX_NUM_ADDENDS, Self::limb_bits()) + div_ceil(LOG2_MAX_NUM_ADDENDS, Self::limb_bits()) } pub fn num_limbs() -> usize { Self::num_result_limbs() + Self::num_carry_limbs() @@ -326,7 +327,7 @@ impl, const D: usize> SimpleGenerator .collect() } - fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) { + fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) -> Result<()> { let local_wire = |column| Wire { row: self.row, column, @@ -351,8 +352,8 @@ impl, const D: usize> SimpleGenerator let output_carry_wire = local_wire(self.gate.wire_ith_output_carry(self.i)); let output_result_wire = local_wire(self.gate.wire_ith_output_result(self.i)); - out_buffer.set_wire(output_carry_wire, output_carry); - out_buffer.set_wire(output_result_wire, output_result); + out_buffer.set_wire(output_carry_wire, output_carry)?; + out_buffer.set_wire(output_result_wire, output_result)?; let num_result_limbs = U32AddManyGate::::num_result_limbs(); let num_carry_limbs = U32AddManyGate::::num_carry_limbs(); @@ -373,8 +374,10 @@ impl, const D: usize> SimpleGenerator for (j, limb) in result_limbs.chain(carry_limbs).enumerate() { let wire = local_wire(self.gate.wire_ith_output_jth_limb(self.i, j)); - out_buffer.set_wire(wire, limb); + out_buffer.set_wire(wire, limb)?; } + + Ok(()) } } diff --git a/src/gates/arithmetic_u32.rs b/src/gates/arithmetic_u32.rs index 5ca4efb..1812547 100644 --- a/src/gates/arithmetic_u32.rs +++ b/src/gates/arithmetic_u32.rs @@ -1,6 +1,7 @@ use alloc::string::{String, ToString}; use alloc::vec::Vec; use alloc::{format, vec}; +use anyhow::Result; use core::marker::PhantomData; use plonky2::util::serialization::{Buffer, IoResult, Read, Write}; @@ -376,7 +377,7 @@ impl, const D: usize> SimpleGenerator ] } - fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) { + fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) -> Result<()> { let local_wire = |column| Wire { row: self.row, column, @@ -400,8 +401,8 @@ impl, const D: usize> SimpleGenerator let output_high_wire = local_wire(self.gate.wire_ith_output_high_half(self.i)); let output_low_wire = local_wire(self.gate.wire_ith_output_low_half(self.i)); - out_buffer.set_wire(output_high_wire, output_high); - out_buffer.set_wire(output_low_wire, output_low); + out_buffer.set_wire(output_high_wire, output_high)?; + out_buffer.set_wire(output_low_wire, output_low)?; let diff = u32::MAX as u64 - output_high_u64; let inverse = if diff == 0 { @@ -410,7 +411,7 @@ impl, const D: usize> SimpleGenerator F::from_canonical_u64(diff).inverse() }; let inverse_wire = local_wire(self.gate.wire_ith_inverse(self.i)); - out_buffer.set_wire(inverse_wire, inverse); + out_buffer.set_wire(inverse_wire, inverse)?; let num_limbs = U32ArithmeticGate::::num_limbs(); let limb_base = 1 << U32ArithmeticGate::::limb_bits(); @@ -424,8 +425,10 @@ impl, const D: usize> SimpleGenerator for (j, output_limb) in output_limbs_f.enumerate() { let wire = local_wire(self.gate.wire_ith_output_jth_limb(self.i, j)); - out_buffer.set_wire(wire, output_limb); + out_buffer.set_wire(wire, output_limb)?; } + + Ok(()) } fn serialize(&self, dst: &mut Vec, common_data: &CommonCircuitData) -> IoResult<()> { diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 5f23cab..0ce9f75 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -1,6 +1,8 @@ use alloc::string::{String, ToString}; use alloc::vec::Vec; use alloc::{format, vec}; +use anyhow::Result; +use num::integer::div_ceil; use core::marker::PhantomData; use plonky2::plonk::circuit_data::CommonCircuitData; use plonky2::util::serialization::{Buffer, IoResult, Read, Write}; @@ -23,7 +25,7 @@ use plonky2::plonk::vars::{ EvaluationTargets, EvaluationVars, EvaluationVarsBase, EvaluationVarsBaseBatch, EvaluationVarsBasePacked, }; -use plonky2::util::{bits_u64, ceil_div_usize}; +use plonky2::util::bits_u64; /// A gate for checking that one value is less than or equal to another. #[derive(Clone, Debug)] @@ -44,7 +46,7 @@ impl, const D: usize> ComparisonGate { } pub fn chunk_bits(&self) -> usize { - ceil_div_usize(self.num_bits, self.num_chunks) + div_ceil(self.num_bits, self.num_chunks) } pub fn wire_first_input(&self) -> usize { @@ -434,7 +436,7 @@ impl, const D: usize> SimpleGenerator ] } - fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) { + fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) -> Result<()> { let local_wire = |column| Wire { row: self.row, column, @@ -502,36 +504,38 @@ impl, const D: usize> SimpleGenerator .map(|x| F::from_canonical_u64(*x)) .collect(); - out_buffer.set_wire(local_wire(self.gate.wire_result_bool()), result); + out_buffer.set_wire(local_wire(self.gate.wire_result_bool()), result)?; out_buffer.set_wire( local_wire(self.gate.wire_most_significant_diff()), most_significant_diff, - ); + )?; for i in 0..self.gate.num_chunks { out_buffer.set_wire( local_wire(self.gate.wire_first_chunk_val(i)), first_input_chunks[i], - ); + )?; out_buffer.set_wire( local_wire(self.gate.wire_second_chunk_val(i)), second_input_chunks[i], - ); + )?; out_buffer.set_wire( local_wire(self.gate.wire_equality_dummy(i)), equality_dummies[i], - ); - out_buffer.set_wire(local_wire(self.gate.wire_chunks_equal(i)), chunks_equal[i]); + )?; + out_buffer.set_wire(local_wire(self.gate.wire_chunks_equal(i)), chunks_equal[i])?; out_buffer.set_wire( local_wire(self.gate.wire_intermediate_value(i)), intermediate_values[i], - ); + )?; } for i in 0..self.gate.chunk_bits() + 1 { out_buffer.set_wire( local_wire(self.gate.wire_most_significant_diff_bit(i)), msd_bits[i], - ); + )?; } + + Ok(()) } fn serialize(&self, dst: &mut Vec, common_data: &CommonCircuitData) -> IoResult<()> { diff --git a/src/gates/range_check_u32.rs b/src/gates/range_check_u32.rs index 1b0d1e4..df80799 100644 --- a/src/gates/range_check_u32.rs +++ b/src/gates/range_check_u32.rs @@ -1,6 +1,8 @@ use alloc::string::{String, ToString}; use alloc::vec::Vec; use alloc::{format, vec}; +use anyhow::Result; +use num::integer::div_ceil; use core::marker::PhantomData; use plonky2::plonk::circuit_data::CommonCircuitData; use plonky2::util::serialization::{Buffer, IoResult, Read, Write}; @@ -17,7 +19,6 @@ use plonky2::iop::witness::{PartitionWitness, Witness, WitnessWrite}; use plonky2::plonk::circuit_builder::CircuitBuilder; use plonky2::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_circuit}; use plonky2::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase}; -use plonky2::util::ceil_div_usize; /// A gate which can decompose a number into base B little-endian limbs. #[derive(Copy, Clone, Debug)] @@ -38,7 +39,7 @@ impl, const D: usize> U32RangeCheckGate { pub const BASE: usize = 1 << Self::AUX_LIMB_BITS; fn aux_limbs_per_input_limb(&self) -> usize { - ceil_div_usize(32, Self::AUX_LIMB_BITS) + div_ceil(32, Self::AUX_LIMB_BITS) } pub fn wire_ith_input_limb(&self, i: usize) -> usize { debug_assert!(i < self.num_input_limbs); @@ -195,7 +196,7 @@ impl, const D: usize> SimpleGenerator .collect() } - fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) { + fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) -> Result<()> { let num_input_limbs = self.gate.num_input_limbs; for i in 0..num_input_limbs { let sum_value = witness @@ -214,9 +215,11 @@ impl, const D: usize> SimpleGenerator .collect::>(); for (b, b_value) in limbs.zip(limbs_value) { - out_buffer.set_target(b, b_value); + out_buffer.set_target(b, b_value)?; } } + + Ok(()) } fn serialize(&self, dst: &mut Vec, common_data: &CommonCircuitData) -> IoResult<()> { @@ -265,7 +268,7 @@ mod tests { const D: usize = 4; const AUX_LIMB_BITS: usize = 2; const BASE: usize = 1 << AUX_LIMB_BITS; - const AUX_LIMBS_PER_INPUT_LIMB: usize = ceil_div_usize(32, AUX_LIMB_BITS); + const AUX_LIMBS_PER_INPUT_LIMB: usize = (32 + AUX_LIMB_BITS - 1)/AUX_LIMB_BITS; fn get_wires(input_limbs: Vec) -> Vec { let num_input_limbs = input_limbs.len(); diff --git a/src/gates/subtraction_u32.rs b/src/gates/subtraction_u32.rs index a0e3a0e..f13e6b6 100644 --- a/src/gates/subtraction_u32.rs +++ b/src/gates/subtraction_u32.rs @@ -1,6 +1,7 @@ use alloc::string::{String, ToString}; use alloc::vec::Vec; use alloc::{format, vec}; +use anyhow::Result; use core::marker::PhantomData; use plonky2::util::serialization::{Buffer, IoResult, Read, Write}; @@ -298,7 +299,7 @@ impl, const D: usize> SimpleGenerator ] } - fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) { + fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) -> Result<()> { let local_wire = |column| Wire { row: self.row, column, @@ -324,8 +325,8 @@ impl, const D: usize> SimpleGenerator let output_result_wire = local_wire(self.gate.wire_ith_output_result(self.i)); let output_borrow_wire = local_wire(self.gate.wire_ith_output_borrow(self.i)); - out_buffer.set_wire(output_result_wire, output_result); - out_buffer.set_wire(output_borrow_wire, output_borrow); + out_buffer.set_wire(output_result_wire, output_result)?; + out_buffer.set_wire(output_borrow_wire, output_borrow)?; let output_result_u64 = output_result.to_canonical_u64(); @@ -341,8 +342,10 @@ impl, const D: usize> SimpleGenerator for j in 0..num_limbs { let wire = local_wire(self.gate.wire_ith_output_jth_limb(self.i, j)); - out_buffer.set_wire(wire, output_limbs[j]); + out_buffer.set_wire(wire, output_limbs[j])?; } + + Ok(()) } fn serialize(&self, dst: &mut Vec, common_data: &CommonCircuitData) -> IoResult<()> { diff --git a/src/witness.rs b/src/witness.rs index cf308d2..e6b0ced 100644 --- a/src/witness.rs +++ b/src/witness.rs @@ -1,3 +1,4 @@ +use anyhow::Result; use plonky2::field::types::{Field, PrimeField64}; use plonky2::iop::generator::GeneratedValues; use plonky2::iop::witness::{Witness, WitnessWrite}; @@ -5,13 +6,13 @@ use plonky2::iop::witness::{Witness, WitnessWrite}; use crate::gadgets::arithmetic_u32::U32Target; pub trait WitnessU32: Witness { - fn set_u32_target(&mut self, target: U32Target, value: u32); + fn set_u32_target(&mut self, target: U32Target, value: u32) -> Result<()>; fn get_u32_target(&self, target: U32Target) -> (u32, u32); } impl, F: PrimeField64> WitnessU32 for T { - fn set_u32_target(&mut self, target: U32Target, value: u32) { - self.set_target(target.0, F::from_canonical_u32(value)); + fn set_u32_target(&mut self, target: U32Target, value: u32) -> Result<()> { + self.set_target(target.0, F::from_canonical_u32(value)) } fn get_u32_target(&self, target: U32Target) -> (u32, u32) { @@ -23,11 +24,11 @@ impl, F: PrimeField64> WitnessU32 for T { } pub trait GeneratedValuesU32 { - fn set_u32_target(&mut self, target: U32Target, value: u32); + fn set_u32_target(&mut self, target: U32Target, value: u32) -> Result<()>; } impl GeneratedValuesU32 for GeneratedValues { - fn set_u32_target(&mut self, target: U32Target, value: u32) { + fn set_u32_target(&mut self, target: U32Target, value: u32) -> Result<()> { self.set_target(target.0, F::from_canonical_u32(value)) } }