arnaucube/plonky2-u32
1
0
Fork 0
mirror of https://github.com/arnaucube/plonky2-u32.git synced 2026-02-10 13:16:46 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix build

Browse Source
This commit is contained in:
Ahmad
2025-05-20 14:42:15 +10:00
parent f652088bc3
commit 9552fcc66b
9 changed files with 62 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/gadgets/arithmetic_u32.rs
View File

@@ -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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
vec![self.x]
}
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) {
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) -> 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)
}
}

4
src/gadgets/multiple_comparison.rs
View File

@@ -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<F: RichField + Extendable<D>, 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;

17
src/gates/add_many_u32.rs
View File

@@ -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<F: RichField + Extendable<D>, const D: usize> U32AddManyGate<F, D> {
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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
.collect()
}
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) {
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) -> Result<()> {
let local_wire = |column| Wire {
row: self.row,
column,
@@ -351,8 +352,8 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
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::<F, D>::num_result_limbs();
let num_carry_limbs = U32AddManyGate::<F, D>::num_carry_limbs();
@@ -373,8 +374,10 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
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(())
}
}

13
src/gates/arithmetic_u32.rs
View File

@@ -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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
]
}
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) {
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) -> Result<()> {
let local_wire = |column| Wire {
row: self.row,
column,
@@ -400,8 +401,8 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
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::<F, D>::num_limbs();
let limb_base = 1 << U32ArithmeticGate::<F, D>::limb_bits();
@@ -424,8 +425,10 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
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<u8>, common_data: &CommonCircuitData<F, D>) -> IoResult<()> {

26
src/gates/comparison.rs
View File

@@ -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<F: RichField + Extendable<D>, const D: usize> ComparisonGate<F, D> {
}
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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
]
}
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) {
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) -> Result<()> {
let local_wire = |column| Wire {
row: self.row,
column,
@@ -502,36 +504,38 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
.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<u8>, common_data: &CommonCircuitData<F, D>) -> IoResult<()> {

13
src/gates/range_check_u32.rs
View File

@@ -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<F: RichField + Extendable<D>, const D: usize> U32RangeCheckGate<F, D> {
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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
.collect()
}
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) {
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) -> 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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
.collect::<Vec<_>>();
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<u8>, common_data: &CommonCircuitData<F, D>) -> 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<u64>) -> Vec<FF> {
let num_input_limbs = input_limbs.len();

11
src/gates/subtraction_u32.rs
View File

@@ -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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
]
}
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) {
fn run_once(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) -> Result<()> {
let local_wire = |column| Wire {
row: self.row,
column,
@@ -324,8 +325,8 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
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<u8>, common_data: &CommonCircuitData<F, D>) -> IoResult<()> {

11
src/witness.rs
View File

@@ -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<F: PrimeField64>: Witness<F> {
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<T: Witness<F>, F: PrimeField64> WitnessU32<F> 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<T: Witness<F>, F: PrimeField64> WitnessU32<F> for T {
}
pub trait GeneratedValuesU32<F: Field> {
fn set_u32_target(&mut self, target: U32Target, value: u32);
fn set_u32_target(&mut self, target: U32Target, value: u32) -> Result<()>;
}
impl<F: Field> GeneratedValuesU32<F> for GeneratedValues<F> {
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))
}
}