plonky2-u32 · arnaucube's git mirror

@@ -10,8 +10,8 @@ [dependencies]
 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" }

M src/gadgets/arithmetic_u32.rs → 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 @@ fn dependencies(&self) -> Vec<Target> {
         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)
     }
 }

M src/gadgets/multiple_comparison.rs → 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 @@ );
     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;

M src/gates/add_many_u32.rs → 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 @@ pub fn limb_bits() -> usize {
         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 @@ .chain([local_target(self.gate.wire_ith_carry(self.i))])
             .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 @@
         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 @@ let carry_limbs = split_to_limbs(output_carry_u64, num_carry_limbs);
 
         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(())
     }
 }

M src/gates/arithmetic_u32.rs → 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 @@ local_target(self.gate.wire_ith_addend(self.i)),
         ]
     }
 
-    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 @@
         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 @@ } else {
             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 @@ let output_limbs_f = output_limbs_u64.map(F::from_canonical_u64);
 
         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<()> {

M src/gates/comparison.rs → 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 @@ }
     }
 
     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 @@ local_target(self.gate.wire_second_input()),
         ]
     }
 
-    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 @@ .iter()
             .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<()> {

M src/gates/range_check_u32.rs → 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 @@ pub const AUX_LIMB_BITS: usize = 2;
     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 @@ .map(|i| Target::wire(self.row, self.gate.wire_ith_input_limb(i)))
             .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 @@ })
                 .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 @@ type FF = QuarticExtension<GoldilocksField>;
         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();

M src/gates/subtraction_u32.rs → 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 @@ local_target(self.gate.wire_ith_input_borrow(self.i)),
         ]
     }
 
-    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 @@
         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 @@ .collect();
 
         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<()> {

M src/witness.rs → 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 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 @@ }
 }
 
 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))
     }
 }