From 9fa050039013c63df5f591d761a621ab6a7cd3c0 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 12:13:32 -0700 Subject: [PATCH 01/28] comparison gate --- src/gates/comparison.rs | 480 ++++++++++++++++++++++++++++++++++++++++ src/gates/mod.rs | 1 + 2 files changed, 481 insertions(+) create mode 100644 src/gates/comparison.rs diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs new file mode 100644 index 00000000..93454ebc --- /dev/null +++ b/src/gates/comparison.rs @@ -0,0 +1,480 @@ +use std::marker::PhantomData; + +use crate::field::extension_field::target::ExtensionTarget; +use crate::field::extension_field::Extendable; +use crate::field::field_types::{Field, PrimeField, RichField}; +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::{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, log2_ceil}; + +/// A gate for checking that one value is smaller than another. +#[derive(Clone, Debug)] +pub(crate) struct ComparisonGate, const D: usize> { + pub(crate) chunk_bits: usize, + pub(crate) num_copies: usize, + _phantom: PhantomData, +} + +impl, const D: usize> ComparisonGate { + pub fn new(num_copies: usize, chunk_bits: usize) -> Self { + Self { + chunk_bits, + num_copies, + _phantom: PhantomData, + } + } + + pub fn field_bits() -> usize { + log2_ceil(F::ORDER) + } + + pub fn num_chunks(&self) -> usize { + ceil_div_usize(Self::field_bits(), self.chunk_bits) + } + + pub fn new_from_config(config: CircuitConfig, chunk_bits: usize) -> Self { + let num_copies = Self::max_num_copies(config.num_routed_wires, chunk_bits); + Self::new(num_copies, chunk_bits) + } + + pub fn max_num_copies(num_routed_wires: usize, chunk_bits: usize) -> usize { + let num_chunks = ceil_div_usize(Self::field_bits(), chunk_bits); + let wires_per_copy = 4 + chunk_bits + 4 * num_chunks; + num_routed_wires / wires_per_copy + } + + pub fn wire_first_input(&self, copy: usize) -> usize { + debug_assert!(copy < self.num_copies); + copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + } + + pub fn wire_second_input(&self, copy: usize) -> usize { + debug_assert!(copy < self.num_copies); + copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + 1 + } + + pub fn wire_z_val(&self, copy: usize) -> usize { + copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + 3 + } + + pub fn wire_z_bit(&self, copy: usize, bit_index: usize) -> usize { + debug_assert!(bit_index < self.chunk_bits + 1); + copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + 4 + bit_index + } + + pub fn wire_first_chunk_val(&self, copy: usize, chunk: usize) -> usize { + debug_assert!(copy < self.num_copies); + debug_assert!(chunk < self.num_chunks()); + copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + 4 + self.chunk_bits + chunk + } + + pub fn wire_second_chunk_val(&self, copy: usize, chunk: usize) -> usize { + debug_assert!(copy < self.num_copies); + debug_assert!(chunk < self.num_chunks()); + copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + + 4 + + self.chunk_bits + + self.num_chunks() + + chunk + } + + pub fn wire_equality_dummy(&self, copy: usize, chunk: usize) -> usize { + debug_assert!(copy < self.num_copies); + debug_assert!(chunk < self.num_chunks()); + copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + + 4 + + self.chunk_bits + + 2 * self.num_chunks() + + chunk + } + + pub fn wire_chunks_equal(&self, copy: usize, chunk: usize) -> usize { + debug_assert!(copy < self.num_copies); + debug_assert!(chunk < self.num_chunks()); + copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + + 4 + + self.chunk_bits + + 3 * self.num_chunks() + + chunk + } +} + +impl, const D: usize> Gate for ComparisonGate { + fn id(&self) -> String { + format!("{:?}", self, D) + } + + fn eval_unfiltered(&self, vars: EvaluationVars) -> Vec { + let mut constraints = Vec::with_capacity(self.num_constraints()); + + for c in 0..self.num_copies { + let first_input = vars.local_wires[self.wire_first_input(c)]; + let second_input = vars.local_wires[self.wire_second_input(c)]; + + // Get chunks and assert that they match + let first_chunks: Vec = (0..self.num_chunks()) + .map(|i| vars.local_wires[self.wire_first_chunk_val(c, i)]) + .collect(); + let second_chunks: Vec = (0..self.num_chunks()) + .map(|i| vars.local_wires[self.wire_second_chunk_val(c, i)]) + .collect(); + + let chunk_base_powers = (0..self.chunk_bits) + .map(|i| F::TWO.exp_u64(i * self.chunk_bits as u64)) + .collect(); + + let first_chunks_combined = first_chunks + .iter() + .zip(chunk_base_powers.iter()) + .map(|(b, x)| b * x) + .fold(F::ZERO, |a, b| a + b); + let second_chunks_combined = second_chunks + .iter() + .zip(chunk_base_powers.iter()) + .map(|(b, x)| b * x) + .fold(F::ZERO, |a, b| a + b); + + constraints.push(first_chunks_combined - first_input); + constraints.push(second_chunks_combined - second_input); + + // Get bits to assert they match the chosen chunk. + let powers_of_two: Vec = (0..self.chunk_bits) + .map(|i| F::TWO.exp_u64(i as u64)) + .collect(); + + let mut most_significant_diff = + first_chunks[self.num_chunks() - 1] - second_chunks[self.num_chunks() - 1]; + + // Find the chosen chunk. + for i in (0..self.num_chunks()).rev() { + let difference = first_chunks[i] - second_chunks[i]; + let equality_dummy = vars.local_wires[self.wire_equality_dummy(c, i)]; + let chunks_equal = vars.local_wires[self.wires_chunks_equal(c, i)]; + + // Two constraints identifying index. + constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); + constraints.push(chunks_equal * difference); + + let this_diff = first_chunks[i] - second_chunks[i]; + most_significant_diff = chunks_equal * most_significant_diff + + (F::Extension::ONE - chunks_equal) * this_diff; + } + + constraints.push(first_bits_combined - most_significant_diff[0]); + constraints.push(second_bits_combined - most_significant_diff[1]); + + let z_bits: Vec = (0..self.chunk_size + 1) + .map(|i| vars.local_wires[self.wire_z_bit(c, i)]) + .collect(); + + let powers_of_two: Vec = (0..self.chunk_bits + 1) + .map(|i| F::TWO.exp_u64(i as u64)) + .collect(); + let z_bits_combined = z_bits + .iter() + .zip(powers_of_two.iter()) + .map(|(b, x)| b * x) + .fold(F::ZERO, |a, b| a + b); + + let two_n = F::TWO.exp_u64(self.chunk_bits); + let (x, y) = most_significant_diff; + constraints.push(z_bits_combined - (two_n + x - y)); + + constraints.push(z_bits[self.chunk_bits - 1]); + } + + constraints + } + + fn eval_unfiltered_base(&self, vars: EvaluationVarsBase) -> Vec { + todo!() + } + + fn eval_unfiltered_recursively( + &self, + builder: &mut CircuitBuilder, + vars: EvaluationTargets, + ) -> Vec> { + todo!() + } + + fn generators( + &self, + gate_index: usize, + _local_constants: &[F], + ) -> Vec>> { + (0..self.num_copies) + .map(|c| { + let g: Box> = Box::new(ComparisonGenerator:: { + gate_index, + gate: self.clone(), + copy: c, + }); + g + }) + .collect() + } + + fn num_wires(&self) -> usize { + self.wire_switch_bool(self.num_copies - 1) + 1 + } + + fn num_constants(&self) -> usize { + 0 + } + + fn degree(&self) -> usize { + 2 + } + + fn num_constraints(&self) -> usize { + 4 * self.num_copies * self.chunk_bits + } +} + +#[derive(Debug)] +struct ComparisonGenerator, const D: usize> { + gate_index: usize, + gate: ComparisonGate, + copy: usize, +} + +impl, const D: usize> SimpleGenerator + for ComparisonGenerator +{ + fn dependencies(&self) -> Vec { + let local_target = |input| Target::wire(self.gate_index, input); + + let mut deps = Vec::new(); + deps.push(local_target(self.gate.wire_first_input(self.copy))); + deps.push(local_target(self.gate.wire_second_input(self.copy))); + deps + } + + fn run_once(&self, witness: &PartitionWitness, out_buffer: &mut GeneratedValues) { + let local_wire = |input| Wire { + gate: self.gate_index, + input, + }; + + let get_local_wire = |input| witness.get_wire(local_wire(input)); + + let first_input = get_local_wire(self.gate.wire_first_input(self.copy)); + let second_input = get_local_wire(self.gate.wire_second_input(self.copy)); + + let field_bits = log2_ceil(F::ORDER); + let first_input_u64 = first_input.to_canonical_u64(); + let second_input_u64 = second_input.to_canonical_u64(); + + let first_input_bits: Vec = (0..field_bits) + .scan(first_input_u64, |acc, _| { + let tmp = *acc % 2; + *acc /= 2; + Some(F::from_canonical_u64(tmp)) + }) + .collect(); + let second_input_bits: Vec = (0..field_bits) + .scan(second_input_u64, |acc, _| { + let tmp = *acc % 2; + *acc /= 2; + Some(F::from_canonical_u64(tmp)) + }) + .collect(); + + let powers_of_two: Vec = (0..self.gate.chunk_bits) + .map(|i| F::TWO.exp_u64(i as u64)) + .collect(); + let first_input_chunks: Vec = first_input_bits + .chunks(self.gate.chunk_bits) + .map(|bits| { + bits.iter() + .zip(powers_of_two.iter()) + .map(|(b, x)| *b * *x) + .fold(F::ZERO, |a, b| a + b) + }) + .collect(); + let second_input_chunks: Vec = second_input_bits + .chunks(self.gate.chunk_bits) + .map(|bits| { + bits.iter() + .zip(powers_of_two.iter()) + .map(|(b, x)| *b * *x) + .fold(F::ZERO, |a, b| a + b) + }) + .collect(); + + let chunks_equal: Vec = (0..self.gate.num_chunks()) + .map(|i| F::from_bool(first_input_chunks[i] == second_input_chunks[i])) + .collect(); + let equality_dummies: Vec = first_input_chunks + .iter() + .zip(second_input_chunks.iter()) + .map(|(f, s)| if *f == *s { F::ONE } else { F::ONE / (*f - *s) }) + .collect(); + + let z = F::TWO.exp_u64(self.gate.chunk_bits as u64) + first_input - second_input; + let z_bits: Vec = (0..self.gate.chunk_bits + 1) + .scan(z.to_canonical_u64(), |acc, _| { + let tmp = *acc % 2; + *acc /= 2; + Some(F::from_canonical_u64(tmp)) + }) + .collect(); + + out_buffer.set_wire(local_wire(self.gate.wire_z_val(self.copy)), z); + for b in 0..self.gate.chunk_bits + 1 { + out_buffer.set_wire(local_wire(self.gate.wire_z_bit(c, b)), z_bits[b]); + } + for i in 0..self.gate.num_chunks() { + out_buffer.set_wire( + local_wire(self.gate.wire_first_chunk_val(self.copy, i)), + first_input_chunks[i], + ); + out_buffer.set_wire( + local_wire(self.gate.wire_second_chunk_val(self.copy, i)), + second_input_chunks[i], + ); + out_buffer.set_wire( + local_wire(self.gate.wire_chunks_equal(self.copy, i)), + chunks_equal[i], + ); + out_buffer.set_wire( + local_wire(self.gate.wire_equality_dummy(self.copy, i)), + equality_dummies[i], + ); + } + } +} + +#[cfg(test)] +mod tests { + use std::marker::PhantomData; + + use anyhow::Result; + + use crate::field::crandall_field::CrandallField; + use crate::field::extension_field::quartic::QuarticCrandallField; + use crate::field::field_types::Field; + use crate::gates::comparison::ComparisonGate; + 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::circuit_data::CircuitConfig; + use crate::plonk::vars::EvaluationVars; + + #[test] + fn wire_indices() { + type CG = ComparisonGate; + let num_copies = 3; + let chunk_bits = 3; + + let gate = CG { + chunk_bits, + num_copies, + _phantom: PhantomData, + }; + + assert_eq!(gate.wire_first_input(0, 0), 0); + assert_eq!(gate.wire_first_input(0, 2), 2); + assert_eq!(gate.wire_second_input(0, 0), 3); + assert_eq!(gate.wire_second_input(0, 2), 5); + assert_eq!(gate.wire_first_output(0, 0), 6); + assert_eq!(gate.wire_second_output(0, 2), 11); + assert_eq!(gate.wire_switch_bool(0), 12); + assert_eq!(gate.wire_first_input(1, 0), 13); + assert_eq!(gate.wire_second_output(1, 2), 24); + assert_eq!(gate.wire_switch_bool(1), 25); + assert_eq!(gate.wire_first_input(2, 0), 26); + assert_eq!(gate.wire_second_output(2, 2), 37); + assert_eq!(gate.wire_switch_bool(2), 38); + } + + #[test] + fn low_degree() { + test_low_degree::(SwitchGate::<_, 4>::new_from_config( + CircuitConfig::large_config(), + 3, + )); + } + + #[test] + fn eval_fns() -> Result<()> { + test_eval_fns::(SwitchGate::<_, 4>::new_from_config( + CircuitConfig::large_config(), + 3, + )) + } + + #[test] + fn test_gate_constraint() { + type F = CrandallField; + type FF = QuarticCrandallField; + const D: usize = 4; + const CHUNK_SIZE: usize = 4; + let num_copies = 3; + + /// Returns the local wires for a switch gate given the inputs and the switch booleans. + fn get_wires( + first_inputs: Vec>, + second_inputs: Vec>, + switch_bools: Vec, + ) -> Vec { + let num_copies = first_inputs.len(); + + let mut v = Vec::new(); + for c in 0..num_copies { + let switch = switch_bools[c]; + + let mut first_input_chunk = Vec::with_capacity(CHUNK_SIZE); + let mut second_input_chunk = Vec::with_capacity(CHUNK_SIZE); + let mut first_output_chunk = Vec::with_capacity(CHUNK_SIZE); + let mut second_output_chunk = Vec::with_capacity(CHUNK_SIZE); + for e in 0..CHUNK_SIZE { + let first_input = first_inputs[c][e]; + let second_input = second_inputs[c][e]; + let first_output = if switch { second_input } else { first_input }; + let second_output = if switch { first_input } else { second_input }; + first_input_chunk.push(first_input); + second_input_chunk.push(second_input); + first_output_chunk.push(first_output); + second_output_chunk.push(second_output); + } + v.append(&mut first_input_chunk); + v.append(&mut second_input_chunk); + v.append(&mut first_output_chunk); + v.append(&mut second_output_chunk); + + v.push(F::from_bool(switch)); + } + + v.iter().map(|&x| x.into()).collect::>() + } + + let first_inputs: Vec> = (0..num_copies).map(|_| F::rand_vec(CHUNK_SIZE)).collect(); + let second_inputs: Vec> = (0..num_copies).map(|_| F::rand_vec(CHUNK_SIZE)).collect(); + let switch_bools = vec![true, false, true]; + + let gate = SwitchGate:: { + chunk_bits: CHUNK_SIZE, + num_copies, + _phantom: PhantomData, + }; + + let vars = EvaluationVars { + local_constants: &[], + local_wires: &get_wires(first_inputs, second_inputs, switch_bools), + public_inputs_hash: &HashOut::rand(), + }; + + assert!( + gate.eval_unfiltered(vars).iter().all(|x| x.is_zero()), + "Gate constraints are not satisfied." + ); + } +} diff --git a/src/gates/mod.rs b/src/gates/mod.rs index 993623c3..053ba3fa 100644 --- a/src/gates/mod.rs +++ b/src/gates/mod.rs @@ -3,6 +3,7 @@ pub mod arithmetic; pub mod base_sum; +pub mod comparison; pub mod constant; pub mod exponentiation; pub mod gate; From 93e6bc626d541a9a593f37ca61ba5085d4327084 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 14:25:22 -0700 Subject: [PATCH 02/28] fixed errors --- src/gates/comparison.rs | 55 +++++++++++++++++++---------------------- 1 file changed, 26 insertions(+), 29 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 93454ebc..f9ef81c4 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -11,7 +11,7 @@ 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, log2_ceil}; +use crate::util::{bits_u64, ceil_div_usize}; /// A gate for checking that one value is smaller than another. #[derive(Clone, Debug)] @@ -31,7 +31,7 @@ impl, const D: usize> ComparisonGate { } pub fn field_bits() -> usize { - log2_ceil(F::ORDER) + bits_u64(F::ORDER) } pub fn num_chunks(&self) -> usize { @@ -118,34 +118,34 @@ impl, const D: usize> Gate for ComparisonGate let second_input = vars.local_wires[self.wire_second_input(c)]; // Get chunks and assert that they match - let first_chunks: Vec = (0..self.num_chunks()) + let first_chunks: Vec = (0..self.num_chunks()) .map(|i| vars.local_wires[self.wire_first_chunk_val(c, i)]) .collect(); - let second_chunks: Vec = (0..self.num_chunks()) + let second_chunks: Vec = (0..self.num_chunks()) .map(|i| vars.local_wires[self.wire_second_chunk_val(c, i)]) .collect(); - let chunk_base_powers = (0..self.chunk_bits) - .map(|i| F::TWO.exp_u64(i * self.chunk_bits as u64)) + let chunk_base_powers: Vec = (0..self.chunk_bits) + .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits) as u64)) .collect(); let first_chunks_combined = first_chunks .iter() .zip(chunk_base_powers.iter()) - .map(|(b, x)| b * x) - .fold(F::ZERO, |a, b| a + b); + .map(|(b, x)| *b * *x) + .fold(F::Extension::ZERO, |a, b| a + b); let second_chunks_combined = second_chunks .iter() .zip(chunk_base_powers.iter()) - .map(|(b, x)| b * x) - .fold(F::ZERO, |a, b| a + b); + .map(|(b, x)| *b * *x) + .fold(F::Extension::ZERO, |a, b| a + b); constraints.push(first_chunks_combined - first_input); constraints.push(second_chunks_combined - second_input); // Get bits to assert they match the chosen chunk. - let powers_of_two: Vec = (0..self.chunk_bits) - .map(|i| F::TWO.exp_u64(i as u64)) + let powers_of_two: Vec = (0..self.chunk_bits) + .map(|i| F::Extension::TWO.exp_u64(i as u64)) .collect(); let mut most_significant_diff = @@ -155,7 +155,7 @@ impl, const D: usize> Gate for ComparisonGate for i in (0..self.num_chunks()).rev() { let difference = first_chunks[i] - second_chunks[i]; let equality_dummy = vars.local_wires[self.wire_equality_dummy(c, i)]; - let chunks_equal = vars.local_wires[self.wires_chunks_equal(c, i)]; + let chunks_equal = vars.local_wires[self.wire_chunks_equal(c, i)]; // Two constraints identifying index. constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); @@ -166,25 +166,21 @@ impl, const D: usize> Gate for ComparisonGate + (F::Extension::ONE - chunks_equal) * this_diff; } - constraints.push(first_bits_combined - most_significant_diff[0]); - constraints.push(second_bits_combined - most_significant_diff[1]); - - let z_bits: Vec = (0..self.chunk_size + 1) + let z_bits: Vec = (0..self.chunk_bits + 1) .map(|i| vars.local_wires[self.wire_z_bit(c, i)]) .collect(); - let powers_of_two: Vec = (0..self.chunk_bits + 1) - .map(|i| F::TWO.exp_u64(i as u64)) + let powers_of_two: Vec = (0..self.chunk_bits + 1) + .map(|i| F::Extension::TWO.exp_u64(i as u64)) .collect(); let z_bits_combined = z_bits .iter() .zip(powers_of_two.iter()) - .map(|(b, x)| b * x) - .fold(F::ZERO, |a, b| a + b); + .map(|(b, x)| *b * *x) + .fold(F::Extension::ZERO, |a, b| a + b); - let two_n = F::TWO.exp_u64(self.chunk_bits); - let (x, y) = most_significant_diff; - constraints.push(z_bits_combined - (two_n + x - y)); + let two_n = F::Extension::TWO.exp_u64(self.chunk_bits as u64); + constraints.push(z_bits_combined - (two_n + most_significant_diff)); constraints.push(z_bits[self.chunk_bits - 1]); } @@ -211,18 +207,19 @@ impl, const D: usize> Gate for ComparisonGate ) -> Vec>> { (0..self.num_copies) .map(|c| { - let g: Box> = Box::new(ComparisonGenerator:: { + let gen = ComparisonGenerator:: { gate_index, gate: self.clone(), copy: c, - }); + }; + let g: Box> = Box::new(gen.adapter()); g }) .collect() } fn num_wires(&self) -> usize { - self.wire_switch_bool(self.num_copies - 1) + 1 + self.wire_chunks_equal(self.num_copies - 1, self.num_chunks() - 1) + 1 } fn num_constants(&self) -> usize { @@ -268,7 +265,7 @@ impl, const D: usize> SimpleGenerator let first_input = get_local_wire(self.gate.wire_first_input(self.copy)); let second_input = get_local_wire(self.gate.wire_second_input(self.copy)); - let field_bits = log2_ceil(F::ORDER); + let field_bits = bits_u64(F::ORDER); let first_input_u64 = first_input.to_canonical_u64(); let second_input_u64 = second_input.to_canonical_u64(); @@ -329,7 +326,7 @@ impl, const D: usize> SimpleGenerator out_buffer.set_wire(local_wire(self.gate.wire_z_val(self.copy)), z); for b in 0..self.gate.chunk_bits + 1 { - out_buffer.set_wire(local_wire(self.gate.wire_z_bit(c, b)), z_bits[b]); + out_buffer.set_wire(local_wire(self.gate.wire_z_bit(self.copy, b)), z_bits[b]); } for i in 0..self.gate.num_chunks() { out_buffer.set_wire( From ada79f7072f8d081def34f2f9d15700c549e99cd Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 14:27:02 -0700 Subject: [PATCH 03/28] cleanup --- src/gates/comparison.rs | 32 ++++++++++++-------------------- 1 file changed, 12 insertions(+), 20 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index f9ef81c4..9b321efe 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -49,59 +49,51 @@ impl, const D: usize> ComparisonGate { num_routed_wires / wires_per_copy } + pub fn wires_per_copy(&self) -> usize { + 4 + self.chunk_bits + 4 * self.num_chunks() + } + pub fn wire_first_input(&self, copy: usize) -> usize { debug_assert!(copy < self.num_copies); - copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + copy * self.wires_per_copy() } pub fn wire_second_input(&self, copy: usize) -> usize { debug_assert!(copy < self.num_copies); - copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + 1 + copy * self.wires_per_copy() + 1 } pub fn wire_z_val(&self, copy: usize) -> usize { - copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + 3 + copy * self.wires_per_copy() + 3 } pub fn wire_z_bit(&self, copy: usize, bit_index: usize) -> usize { debug_assert!(bit_index < self.chunk_bits + 1); - copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + 4 + bit_index + copy * self.wires_per_copy() + 4 + bit_index } pub fn wire_first_chunk_val(&self, copy: usize, chunk: usize) -> usize { debug_assert!(copy < self.num_copies); debug_assert!(chunk < self.num_chunks()); - copy * (4 + self.chunk_bits + 4 * self.num_chunks()) + 4 + self.chunk_bits + chunk + copy * self.wires_per_copy() + 4 + self.chunk_bits + chunk } pub fn wire_second_chunk_val(&self, copy: usize, chunk: usize) -> usize { debug_assert!(copy < self.num_copies); debug_assert!(chunk < self.num_chunks()); - copy * (4 + self.chunk_bits + 4 * self.num_chunks()) - + 4 - + self.chunk_bits - + self.num_chunks() - + chunk + copy * self.wires_per_copy() + 4 + self.chunk_bits + self.num_chunks() + chunk } pub fn wire_equality_dummy(&self, copy: usize, chunk: usize) -> usize { debug_assert!(copy < self.num_copies); debug_assert!(chunk < self.num_chunks()); - copy * (4 + self.chunk_bits + 4 * self.num_chunks()) - + 4 - + self.chunk_bits - + 2 * self.num_chunks() - + chunk + copy * self.wires_per_copy() + 4 + self.chunk_bits + 2 * self.num_chunks() + chunk } pub fn wire_chunks_equal(&self, copy: usize, chunk: usize) -> usize { debug_assert!(copy < self.num_copies); debug_assert!(chunk < self.num_chunks()); - copy * (4 + self.chunk_bits + 4 * self.num_chunks()) - + 4 - + self.chunk_bits - + 3 * self.num_chunks() - + chunk + copy * self.wires_per_copy() + 4 + self.chunk_bits + 3 * self.num_chunks() + chunk } } From 542bc6283c353e366fcfa6fa258c1c788bbef23f Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 14:52:02 -0700 Subject: [PATCH 04/28] added num_bits --- src/gates/comparison.rs | 100 ++++++++++++++++++++++------------------ 1 file changed, 56 insertions(+), 44 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 9b321efe..0ac911ee 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -16,16 +16,18 @@ use crate::util::{bits_u64, ceil_div_usize}; /// A gate for checking that one value is smaller than another. #[derive(Clone, Debug)] pub(crate) struct ComparisonGate, const D: usize> { - pub(crate) chunk_bits: usize, pub(crate) num_copies: usize, + pub(crate) num_bits: usize, + pub(crate) num_chunks: usize, _phantom: PhantomData, } impl, const D: usize> ComparisonGate { - pub fn new(num_copies: usize, chunk_bits: usize) -> Self { + pub fn new(num_copies: usize, num_bits: usize, num_chunks: usize) -> Self { Self { - chunk_bits, num_copies, + num_bits, + num_chunks, _phantom: PhantomData, } } @@ -34,23 +36,23 @@ impl, const D: usize> ComparisonGate { bits_u64(F::ORDER) } - pub fn num_chunks(&self) -> usize { - ceil_div_usize(Self::field_bits(), self.chunk_bits) + pub fn chunk_bits(&self) -> usize { + ceil_div_usize(self.num_bits, self.num_chunks) } - pub fn new_from_config(config: CircuitConfig, chunk_bits: usize) -> Self { - let num_copies = Self::max_num_copies(config.num_routed_wires, chunk_bits); - Self::new(num_copies, chunk_bits) + pub fn new_from_config(config: CircuitConfig, num_bits: usize, num_chunks: usize) -> Self { + let num_copies = Self::max_num_copies(config.num_routed_wires, num_bits, num_chunks); + Self::new(num_copies, num_bits, num_chunks) } - pub fn max_num_copies(num_routed_wires: usize, chunk_bits: usize) -> usize { - let num_chunks = ceil_div_usize(Self::field_bits(), chunk_bits); + pub fn max_num_copies(num_routed_wires: usize, num_bits: usize, num_chunks: usize) -> usize { + let chunk_bits = ceil_div_usize(num_bits, num_chunks); let wires_per_copy = 4 + chunk_bits + 4 * num_chunks; num_routed_wires / wires_per_copy } pub fn wires_per_copy(&self) -> usize { - 4 + self.chunk_bits + 4 * self.num_chunks() + 4 + self.chunk_bits() + 4 * self.num_chunks } pub fn wire_first_input(&self, copy: usize) -> usize { @@ -68,32 +70,32 @@ impl, const D: usize> ComparisonGate { } pub fn wire_z_bit(&self, copy: usize, bit_index: usize) -> usize { - debug_assert!(bit_index < self.chunk_bits + 1); + debug_assert!(bit_index < self.chunk_bits() + 1); copy * self.wires_per_copy() + 4 + bit_index } pub fn wire_first_chunk_val(&self, copy: usize, chunk: usize) -> usize { debug_assert!(copy < self.num_copies); - debug_assert!(chunk < self.num_chunks()); - copy * self.wires_per_copy() + 4 + self.chunk_bits + chunk + debug_assert!(chunk < self.num_chunks); + copy * self.wires_per_copy() + 4 + self.chunk_bits() + chunk } pub fn wire_second_chunk_val(&self, copy: usize, chunk: usize) -> usize { debug_assert!(copy < self.num_copies); - debug_assert!(chunk < self.num_chunks()); - copy * self.wires_per_copy() + 4 + self.chunk_bits + self.num_chunks() + chunk + debug_assert!(chunk < self.num_chunks); + copy * self.wires_per_copy() + 4 + self.chunk_bits() + self.num_chunks + chunk } pub fn wire_equality_dummy(&self, copy: usize, chunk: usize) -> usize { debug_assert!(copy < self.num_copies); - debug_assert!(chunk < self.num_chunks()); - copy * self.wires_per_copy() + 4 + self.chunk_bits + 2 * self.num_chunks() + chunk + debug_assert!(chunk < self.num_chunks); + copy * self.wires_per_copy() + 4 + self.chunk_bits() + 2 * self.num_chunks + chunk } pub fn wire_chunks_equal(&self, copy: usize, chunk: usize) -> usize { debug_assert!(copy < self.num_copies); - debug_assert!(chunk < self.num_chunks()); - copy * self.wires_per_copy() + 4 + self.chunk_bits + 3 * self.num_chunks() + chunk + debug_assert!(chunk < self.num_chunks); + copy * self.wires_per_copy() + 4 + self.chunk_bits() + 3 * self.num_chunks + chunk } } @@ -110,15 +112,15 @@ impl, const D: usize> Gate for ComparisonGate let second_input = vars.local_wires[self.wire_second_input(c)]; // Get chunks and assert that they match - let first_chunks: Vec = (0..self.num_chunks()) + let first_chunks: Vec = (0..self.num_chunks) .map(|i| vars.local_wires[self.wire_first_chunk_val(c, i)]) .collect(); - let second_chunks: Vec = (0..self.num_chunks()) + let second_chunks: Vec = (0..self.num_chunks) .map(|i| vars.local_wires[self.wire_second_chunk_val(c, i)]) .collect(); - let chunk_base_powers: Vec = (0..self.chunk_bits) - .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits) as u64)) + let chunk_base_powers: Vec = (0..self.chunk_bits()) + .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits()) as u64)) .collect(); let first_chunks_combined = first_chunks @@ -136,15 +138,15 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(second_chunks_combined - second_input); // Get bits to assert they match the chosen chunk. - let powers_of_two: Vec = (0..self.chunk_bits) + let powers_of_two: Vec = (0..self.chunk_bits()) .map(|i| F::Extension::TWO.exp_u64(i as u64)) .collect(); let mut most_significant_diff = - first_chunks[self.num_chunks() - 1] - second_chunks[self.num_chunks() - 1]; + first_chunks[self.num_chunks - 1] - second_chunks[self.num_chunks - 1]; // Find the chosen chunk. - for i in (0..self.num_chunks()).rev() { + for i in (0..self.num_chunks).rev() { let difference = first_chunks[i] - second_chunks[i]; let equality_dummy = vars.local_wires[self.wire_equality_dummy(c, i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(c, i)]; @@ -158,11 +160,11 @@ impl, const D: usize> Gate for ComparisonGate + (F::Extension::ONE - chunks_equal) * this_diff; } - let z_bits: Vec = (0..self.chunk_bits + 1) + let z_bits: Vec = (0..self.chunk_bits() + 1) .map(|i| vars.local_wires[self.wire_z_bit(c, i)]) .collect(); - let powers_of_two: Vec = (0..self.chunk_bits + 1) + let powers_of_two: Vec = (0..self.chunk_bits() + 1) .map(|i| F::Extension::TWO.exp_u64(i as u64)) .collect(); let z_bits_combined = z_bits @@ -171,10 +173,10 @@ impl, const D: usize> Gate for ComparisonGate .map(|(b, x)| *b * *x) .fold(F::Extension::ZERO, |a, b| a + b); - let two_n = F::Extension::TWO.exp_u64(self.chunk_bits as u64); + let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); constraints.push(z_bits_combined - (two_n + most_significant_diff)); - constraints.push(z_bits[self.chunk_bits - 1]); + constraints.push(z_bits[self.chunk_bits() - 1]); } constraints @@ -211,7 +213,7 @@ impl, const D: usize> Gate for ComparisonGate } fn num_wires(&self) -> usize { - self.wire_chunks_equal(self.num_copies - 1, self.num_chunks() - 1) + 1 + self.wire_chunks_equal(self.num_copies - 1, self.num_chunks - 1) + 1 } fn num_constants(&self) -> usize { @@ -223,7 +225,7 @@ impl, const D: usize> Gate for ComparisonGate } fn num_constraints(&self) -> usize { - 4 * self.num_copies * self.chunk_bits + 4 * self.num_copies * self.chunk_bits() } } @@ -276,11 +278,11 @@ impl, const D: usize> SimpleGenerator }) .collect(); - let powers_of_two: Vec = (0..self.gate.chunk_bits) + let powers_of_two: Vec = (0..self.gate.chunk_bits()) .map(|i| F::TWO.exp_u64(i as u64)) .collect(); let first_input_chunks: Vec = first_input_bits - .chunks(self.gate.chunk_bits) + .chunks(self.gate.chunk_bits()) .map(|bits| { bits.iter() .zip(powers_of_two.iter()) @@ -289,7 +291,7 @@ impl, const D: usize> SimpleGenerator }) .collect(); let second_input_chunks: Vec = second_input_bits - .chunks(self.gate.chunk_bits) + .chunks(self.gate.chunk_bits()) .map(|bits| { bits.iter() .zip(powers_of_two.iter()) @@ -298,7 +300,7 @@ impl, const D: usize> SimpleGenerator }) .collect(); - let chunks_equal: Vec = (0..self.gate.num_chunks()) + let chunks_equal: Vec = (0..self.gate.num_chunks) .map(|i| F::from_bool(first_input_chunks[i] == second_input_chunks[i])) .collect(); let equality_dummies: Vec = first_input_chunks @@ -307,8 +309,8 @@ impl, const D: usize> SimpleGenerator .map(|(f, s)| if *f == *s { F::ONE } else { F::ONE / (*f - *s) }) .collect(); - let z = F::TWO.exp_u64(self.gate.chunk_bits as u64) + first_input - second_input; - let z_bits: Vec = (0..self.gate.chunk_bits + 1) + let z = F::TWO.exp_u64(self.gate.chunk_bits() as u64) + first_input - second_input; + let z_bits: Vec = (0..self.gate.chunk_bits() + 1) .scan(z.to_canonical_u64(), |acc, _| { let tmp = *acc % 2; *acc /= 2; @@ -317,10 +319,10 @@ impl, const D: usize> SimpleGenerator .collect(); out_buffer.set_wire(local_wire(self.gate.wire_z_val(self.copy)), z); - for b in 0..self.gate.chunk_bits + 1 { + for b in 0..self.gate.chunk_bits() + 1 { out_buffer.set_wire(local_wire(self.gate.wire_z_bit(self.copy, b)), z_bits[b]); } - for i in 0..self.gate.num_chunks() { + for i in 0..self.gate.num_chunks { out_buffer.set_wire( local_wire(self.gate.wire_first_chunk_val(self.copy, i)), first_input_chunks[i], @@ -348,7 +350,7 @@ mod tests { use anyhow::Result; use crate::field::crandall_field::CrandallField; - use crate::field::extension_field::quartic::QuarticCrandallField; + use crate::field::extension_field::quartic::QuarticExtension; use crate::field::field_types::Field; use crate::gates::comparison::ComparisonGate; use crate::gates::gate::Gate; @@ -360,15 +362,25 @@ mod tests { #[test] fn wire_indices() { type CG = ComparisonGate; + let num_bits = 40; let num_copies = 3; - let chunk_bits = 3; + let num_chunks = 5; let gate = CG { - chunk_bits, + num_bits, + num_chunks, num_copies, _phantom: PhantomData, }; + assert_eq!(gate.wire_first_input(0), 0); + assert_eq!(gate.wire_second_input(0), 1); + assert_eq!(gate.wire_z_val(0), 2); + assert_eq!(gate.wire_z_bit(0, 0), 3); + assert_eq!(gate.wire_z_bit(0, 3), 6); + assert_eq!(gate.wire_first_chunk_val(0, 0), 7); + assert_eq!(gate.wire_first_chunk_val(0, 0), 7); + assert_eq!(gate.wire_first_input(0, 0), 0); assert_eq!(gate.wire_first_input(0, 2), 2); assert_eq!(gate.wire_second_input(0, 0), 3); From 8731f8136f5955e245c14fcd4296a5a6467a9edc Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 15:11:33 -0700 Subject: [PATCH 05/28] some tests --- src/gates/comparison.rs | 116 ++++++++++------------------------------ 1 file changed, 29 insertions(+), 87 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 0ac911ee..1e57c75a 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -66,12 +66,12 @@ impl, const D: usize> ComparisonGate { } pub fn wire_z_val(&self, copy: usize) -> usize { - copy * self.wires_per_copy() + 3 + copy * self.wires_per_copy() + 2 } pub fn wire_z_bit(&self, copy: usize, bit_index: usize) -> usize { debug_assert!(bit_index < self.chunk_bits() + 1); - copy * self.wires_per_copy() + 4 + bit_index + copy * self.wires_per_copy() + 3 + bit_index } pub fn wire_first_chunk_val(&self, copy: usize, chunk: usize) -> usize { @@ -377,105 +377,47 @@ mod tests { assert_eq!(gate.wire_second_input(0), 1); assert_eq!(gate.wire_z_val(0), 2); assert_eq!(gate.wire_z_bit(0, 0), 3); - assert_eq!(gate.wire_z_bit(0, 3), 6); - assert_eq!(gate.wire_first_chunk_val(0, 0), 7); - assert_eq!(gate.wire_first_chunk_val(0, 0), 7); - - assert_eq!(gate.wire_first_input(0, 0), 0); - assert_eq!(gate.wire_first_input(0, 2), 2); - assert_eq!(gate.wire_second_input(0, 0), 3); - assert_eq!(gate.wire_second_input(0, 2), 5); - assert_eq!(gate.wire_first_output(0, 0), 6); - assert_eq!(gate.wire_second_output(0, 2), 11); - assert_eq!(gate.wire_switch_bool(0), 12); - assert_eq!(gate.wire_first_input(1, 0), 13); - assert_eq!(gate.wire_second_output(1, 2), 24); - assert_eq!(gate.wire_switch_bool(1), 25); - assert_eq!(gate.wire_first_input(2, 0), 26); - assert_eq!(gate.wire_second_output(2, 2), 37); - assert_eq!(gate.wire_switch_bool(2), 38); + assert_eq!(gate.wire_z_bit(0, 8), 11); + assert_eq!(gate.wire_first_chunk_val(0, 0), 12); + assert_eq!(gate.wire_first_chunk_val(0, 4), 16); + assert_eq!(gate.wire_second_chunk_val(0, 0), 17); + assert_eq!(gate.wire_second_chunk_val(0, 4), 21); + assert_eq!(gate.wire_equality_dummy(0, 0), 22); + assert_eq!(gate.wire_equality_dummy(0, 4), 26); + assert_eq!(gate.wire_chunks_equal(0, 0), 27); + assert_eq!(gate.wire_chunks_equal(0, 4), 31); + assert_eq!(gate.wire_first_input(1), 32); + assert_eq!(gate.wire_chunks_equal(1, 4), 63); + assert_eq!(gate.wire_first_input(2), 64); + assert_eq!(gate.wire_chunks_equal(2, 4), 95); } #[test] fn low_degree() { - test_low_degree::(SwitchGate::<_, 4>::new_from_config( + let num_bits = 40; + let num_chunks = 5; + + test_low_degree::(ComparisonGate::<_, 4>::new_from_config( CircuitConfig::large_config(), - 3, - )); + num_bits, + num_chunks, + )) } #[test] fn eval_fns() -> Result<()> { - test_eval_fns::(SwitchGate::<_, 4>::new_from_config( + let num_bits = 40; + let num_chunks = 5; + + test_eval_fns::(ComparisonGate::<_, 4>::new_from_config( CircuitConfig::large_config(), - 3, + num_bits, + num_chunks, )) } #[test] fn test_gate_constraint() { - type F = CrandallField; - type FF = QuarticCrandallField; - const D: usize = 4; - const CHUNK_SIZE: usize = 4; - let num_copies = 3; - - /// Returns the local wires for a switch gate given the inputs and the switch booleans. - fn get_wires( - first_inputs: Vec>, - second_inputs: Vec>, - switch_bools: Vec, - ) -> Vec { - let num_copies = first_inputs.len(); - - let mut v = Vec::new(); - for c in 0..num_copies { - let switch = switch_bools[c]; - - let mut first_input_chunk = Vec::with_capacity(CHUNK_SIZE); - let mut second_input_chunk = Vec::with_capacity(CHUNK_SIZE); - let mut first_output_chunk = Vec::with_capacity(CHUNK_SIZE); - let mut second_output_chunk = Vec::with_capacity(CHUNK_SIZE); - for e in 0..CHUNK_SIZE { - let first_input = first_inputs[c][e]; - let second_input = second_inputs[c][e]; - let first_output = if switch { second_input } else { first_input }; - let second_output = if switch { first_input } else { second_input }; - first_input_chunk.push(first_input); - second_input_chunk.push(second_input); - first_output_chunk.push(first_output); - second_output_chunk.push(second_output); - } - v.append(&mut first_input_chunk); - v.append(&mut second_input_chunk); - v.append(&mut first_output_chunk); - v.append(&mut second_output_chunk); - - v.push(F::from_bool(switch)); - } - - v.iter().map(|&x| x.into()).collect::>() - } - - let first_inputs: Vec> = (0..num_copies).map(|_| F::rand_vec(CHUNK_SIZE)).collect(); - let second_inputs: Vec> = (0..num_copies).map(|_| F::rand_vec(CHUNK_SIZE)).collect(); - let switch_bools = vec![true, false, true]; - - let gate = SwitchGate:: { - chunk_bits: CHUNK_SIZE, - num_copies, - _phantom: PhantomData, - }; - - let vars = EvaluationVars { - local_constants: &[], - local_wires: &get_wires(first_inputs, second_inputs, switch_bools), - public_inputs_hash: &HashOut::rand(), - }; - - assert!( - gate.eval_unfiltered(vars).iter().all(|x| x.is_zero()), - "Gate constraints are not satisfied." - ); + todo!() } } From 18738e5984dce6117283da10d95d5a550f15ff2a Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 15:14:54 -0700 Subject: [PATCH 06/28] fixes --- src/gates/comparison.rs | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 1e57c75a..fa588181 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -137,11 +137,6 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_chunks_combined - first_input); constraints.push(second_chunks_combined - second_input); - // Get bits to assert they match the chosen chunk. - let powers_of_two: Vec = (0..self.chunk_bits()) - .map(|i| F::Extension::TWO.exp_u64(i as u64)) - .collect(); - let mut most_significant_diff = first_chunks[self.num_chunks - 1] - second_chunks[self.num_chunks - 1]; @@ -221,11 +216,11 @@ impl, const D: usize> Gate for ComparisonGate } fn degree(&self) -> usize { - 2 + self.num_chunks + 1 } fn num_constraints(&self) -> usize { - 4 * self.num_copies * self.chunk_bits() + self.num_copies * (4 + 2 * self.num_chunks) } } From 4484a42d93dbed3e95d46ba5912ac072738c7e39 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 17:17:31 -0700 Subject: [PATCH 07/28] test_gate_constraints --- src/gates/comparison.rs | 120 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 111 insertions(+), 9 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index fa588181..eb21eb94 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -32,10 +32,6 @@ impl, const D: usize> ComparisonGate { } } - pub fn field_bits() -> usize { - bits_u64(F::ORDER) - } - pub fn chunk_bits(&self) -> usize { ceil_div_usize(self.num_bits, self.num_chunks) } @@ -254,18 +250,17 @@ impl, const D: usize> SimpleGenerator let first_input = get_local_wire(self.gate.wire_first_input(self.copy)); let second_input = get_local_wire(self.gate.wire_second_input(self.copy)); - let field_bits = bits_u64(F::ORDER); let first_input_u64 = first_input.to_canonical_u64(); let second_input_u64 = second_input.to_canonical_u64(); - let first_input_bits: Vec = (0..field_bits) + let first_input_bits: Vec = (0..self.gate.num_bits) .scan(first_input_u64, |acc, _| { let tmp = *acc % 2; *acc /= 2; Some(F::from_canonical_u64(tmp)) }) .collect(); - let second_input_bits: Vec = (0..field_bits) + let second_input_bits: Vec = (0..self.gate.num_bits) .scan(second_input_u64, |acc, _| { let tmp = *acc % 2; *acc /= 2; @@ -346,7 +341,7 @@ mod tests { use crate::field::crandall_field::CrandallField; use crate::field::extension_field::quartic::QuarticExtension; - use crate::field::field_types::Field; + use crate::field::field_types::{Field, PrimeField}; use crate::gates::comparison::ComparisonGate; use crate::gates::gate::Gate; use crate::gates::gate_testing::{test_eval_fns, test_low_degree}; @@ -413,6 +408,113 @@ mod tests { #[test] fn test_gate_constraint() { - todo!() + type F = CrandallField; + type FF = QuarticExtension; + const D: usize = 4; + + let num_copies = 3; + let num_bits = 40; + let num_chunks = 5; + let chunk_bits = num_bits / num_chunks; + + // Returns the local wires for a comparison gate given the two inputs. + let get_wires = |first_inputs: Vec, second_inputs: Vec| -> Vec { + let num_copies = first_inputs.len(); + + let mut v = Vec::new(); + for c in 0..num_copies { + let first_input = first_inputs[c]; + let second_input = second_inputs[c]; + + let first_input_u64 = first_input.to_canonical_u64(); + let second_input_u64 = second_input.to_canonical_u64(); + + let first_input_bits: Vec = (0..num_bits) + .scan(first_input_u64, |acc, _| { + let tmp = *acc % 2; + *acc /= 2; + Some(F::from_canonical_u64(tmp)) + }) + .collect(); + let second_input_bits: Vec = (0..num_bits) + .scan(second_input_u64, |acc, _| { + let tmp = *acc % 2; + *acc /= 2; + Some(F::from_canonical_u64(tmp)) + }) + .collect(); + + let powers_of_two: Vec = + (0..chunk_bits).map(|i| F::TWO.exp_u64(i as u64)).collect(); + let mut first_input_chunks: Vec = first_input_bits + .chunks(chunk_bits) + .map(|bits| { + bits.iter() + .zip(powers_of_two.iter()) + .map(|(b, x)| *b * *x) + .fold(F::ZERO, |a, b| a + b) + }) + .collect(); + let mut second_input_chunks: Vec = second_input_bits + .chunks(chunk_bits) + .map(|bits| { + bits.iter() + .zip(powers_of_two.iter()) + .map(|(b, x)| *b * *x) + .fold(F::ZERO, |a, b| a + b) + }) + .collect(); + + let mut chunks_equal: Vec = (0..num_chunks) + .map(|i| F::from_bool(first_input_chunks[i] == second_input_chunks[i])) + .collect(); + let mut equality_dummies: Vec = first_input_chunks + .iter() + .zip(second_input_chunks.iter()) + .map(|(f, s)| if *f == *s { F::ONE } else { F::ONE / (*f - *s) }) + .collect(); + + let z = F::TWO.exp_u64(chunk_bits as u64) + first_input - second_input; + let mut z_bits: Vec = (0..chunk_bits + 1) + .scan(z.to_canonical_u64(), |acc, _| { + let tmp = *acc % 2; + *acc /= 2; + Some(F::from_canonical_u64(tmp)) + }) + .collect(); + + v.push(first_input); + v.push(second_input); + v.push(z); + v.append(&mut first_input_chunks); + v.append(&mut second_input_chunks); + v.append(&mut z_bits); + v.append(&mut equality_dummies); + v.append(&mut chunks_equal); + } + + v.iter().map(|&x| x.into()).collect::>() + }; + + let first_inputs = F::rand_vec(num_copies); + let second_inputs = F::rand_vec(num_copies); + + let gate = ComparisonGate:: { + num_copies, + num_bits, + num_chunks, + _phantom: PhantomData, + }; + + let vars = EvaluationVars { + local_constants: &[], + local_wires: &get_wires(first_inputs, second_inputs), + public_inputs_hash: &HashOut::rand(), + }; + + assert!( + gate.eval_unfiltered(vars).iter().all(|x| x.is_zero()), + "Gate constraints are not satisfied." + ); } } From 6807c14c417ff7df8db2109aeed90f0bf38c3959 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 17:51:48 -0700 Subject: [PATCH 08/28] fix --- src/gates/comparison.rs | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index eb21eb94..702be458 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -115,7 +115,7 @@ impl, const D: usize> Gate for ComparisonGate .map(|i| vars.local_wires[self.wire_second_chunk_val(c, i)]) .collect(); - let chunk_base_powers: Vec = (0..self.chunk_bits()) + let chunk_base_powers: Vec = (0..self.num_chunks) .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits()) as u64)) .collect(); @@ -143,8 +143,8 @@ impl, const D: usize> Gate for ComparisonGate let chunks_equal = vars.local_wires[self.wire_chunks_equal(c, i)]; // Two constraints identifying index. - constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); - constraints.push(chunks_equal * difference); + //constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); + //constraints.push(chunks_equal * difference); let this_diff = first_chunks[i] - second_chunks[i]; most_significant_diff = chunks_equal * most_significant_diff @@ -165,9 +165,9 @@ impl, const D: usize> Gate for ComparisonGate .fold(F::Extension::ZERO, |a, b| a + b); let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); - constraints.push(z_bits_combined - (two_n + most_significant_diff)); + //constraints.push(z_bits_combined - (two_n + most_significant_diff)); - constraints.push(z_bits[self.chunk_bits() - 1]); + //constraints.push(z_bits[self.chunk_bits() - 1]); } constraints @@ -335,9 +335,9 @@ impl, const D: usize> SimpleGenerator #[cfg(test)] mod tests { - use std::marker::PhantomData; - use anyhow::Result; + use rand::Rng; + use std::marker::PhantomData; use crate::field::crandall_field::CrandallField; use crate::field::extension_field::quartic::QuarticExtension; @@ -496,8 +496,10 @@ mod tests { v.iter().map(|&x| x.into()).collect::>() }; - let first_inputs = F::rand_vec(num_copies); - let second_inputs = F::rand_vec(num_copies); + let mut rng = rand::thread_rng(); + let max: u64 = 1 << num_bits - 1; + let first_inputs = (0..num_copies).map(|_| F::from_canonical_u64(rng.gen_range(0..max))).collect(); + let second_inputs = (0..num_copies).map(|_| F::from_canonical_u64(rng.gen_range(0..max))).collect(); let gate = ComparisonGate:: { num_copies, From 75ff36decb6668c19d3f988011b561da1b5edcda Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 17:51:55 -0700 Subject: [PATCH 09/28] fmt --- src/gates/comparison.rs | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 702be458..f1c93de2 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -335,9 +335,10 @@ impl, const D: usize> SimpleGenerator #[cfg(test)] mod tests { + use std::marker::PhantomData; + use anyhow::Result; use rand::Rng; - use std::marker::PhantomData; use crate::field::crandall_field::CrandallField; use crate::field::extension_field::quartic::QuarticExtension; @@ -498,8 +499,12 @@ mod tests { let mut rng = rand::thread_rng(); let max: u64 = 1 << num_bits - 1; - let first_inputs = (0..num_copies).map(|_| F::from_canonical_u64(rng.gen_range(0..max))).collect(); - let second_inputs = (0..num_copies).map(|_| F::from_canonical_u64(rng.gen_range(0..max))).collect(); + let first_inputs = (0..num_copies) + .map(|_| F::from_canonical_u64(rng.gen_range(0..max))) + .collect(); + let second_inputs = (0..num_copies) + .map(|_| F::from_canonical_u64(rng.gen_range(0..max))) + .collect(); let gate = ComparisonGate:: { num_copies, From 63246bc2f7a54e7b7b5f51f7b3fa9306941bcfc4 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 18:02:34 -0700 Subject: [PATCH 10/28] fix (wires were out of order) --- src/gates/comparison.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index f1c93de2..223ab54d 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -487,9 +487,9 @@ mod tests { v.push(first_input); v.push(second_input); v.push(z); + v.append(&mut z_bits); v.append(&mut first_input_chunks); v.append(&mut second_input_chunks); - v.append(&mut z_bits); v.append(&mut equality_dummies); v.append(&mut chunks_equal); } From 4eda0e9e9be9096d709d71e7bcef1e740dea9bc4 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 18:03:57 -0700 Subject: [PATCH 11/28] fix (z calculated incorrectly) --- src/gates/comparison.rs | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 223ab54d..baf0270e 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -133,18 +133,17 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_chunks_combined - first_input); constraints.push(second_chunks_combined - second_input); - let mut most_significant_diff = - first_chunks[self.num_chunks - 1] - second_chunks[self.num_chunks - 1]; + let mut most_significant_diff = F::Extension::ZERO; // Find the chosen chunk. - for i in (0..self.num_chunks).rev() { + for i in 0..self.num_chunks { let difference = first_chunks[i] - second_chunks[i]; let equality_dummy = vars.local_wires[self.wire_equality_dummy(c, i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(c, i)]; // Two constraints identifying index. - //constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); - //constraints.push(chunks_equal * difference); + constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); + constraints.push(chunks_equal * difference); let this_diff = first_chunks[i] - second_chunks[i]; most_significant_diff = chunks_equal * most_significant_diff @@ -165,7 +164,7 @@ impl, const D: usize> Gate for ComparisonGate .fold(F::Extension::ZERO, |a, b| a + b); let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); - //constraints.push(z_bits_combined - (two_n + most_significant_diff)); + constraints.push(z_bits_combined - (two_n + most_significant_diff)); //constraints.push(z_bits[self.chunk_bits() - 1]); } @@ -299,7 +298,15 @@ impl, const D: usize> SimpleGenerator .map(|(f, s)| if *f == *s { F::ONE } else { F::ONE / (*f - *s) }) .collect(); - let z = F::TWO.exp_u64(self.gate.chunk_bits() as u64) + first_input - second_input; + let mut diff_index = 0; + for i in 1..self.gate.num_chunks { + if first_input_chunks[i] != second_input_chunks[i] { + diff_index = i; + } + } + let most_significant_diff = first_input_chunks[diff_index] - second_input_chunks[diff_index]; + + let z = F::TWO.exp_u64(self.gate.chunk_bits() as u64) + most_significant_diff; let z_bits: Vec = (0..self.gate.chunk_bits() + 1) .scan(z.to_canonical_u64(), |acc, _| { let tmp = *acc % 2; @@ -474,8 +481,16 @@ mod tests { .zip(second_input_chunks.iter()) .map(|(f, s)| if *f == *s { F::ONE } else { F::ONE / (*f - *s) }) .collect(); + + let mut diff_index = 0; + for i in 1..num_chunks { + if first_input_chunks[i] != second_input_chunks[i] { + diff_index = i; + } + } + let most_significant_diff = first_input_chunks[diff_index] - second_input_chunks[diff_index]; - let z = F::TWO.exp_u64(chunk_bits as u64) + first_input - second_input; + let z = F::TWO.exp_u64(chunk_bits as u64) + most_significant_diff; let mut z_bits: Vec = (0..chunk_bits + 1) .scan(z.to_canonical_u64(), |acc, _| { let tmp = *acc % 2; From 8a726d5a8612cd8c004f3c9ab1930494bfa880c2 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Mon, 13 Sep 2021 18:05:42 -0700 Subject: [PATCH 12/28] fmt --- src/gates/comparison.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index baf0270e..4f6186da 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -304,7 +304,8 @@ impl, const D: usize> SimpleGenerator diff_index = i; } } - let most_significant_diff = first_input_chunks[diff_index] - second_input_chunks[diff_index]; + let most_significant_diff = + first_input_chunks[diff_index] - second_input_chunks[diff_index]; let z = F::TWO.exp_u64(self.gate.chunk_bits() as u64) + most_significant_diff; let z_bits: Vec = (0..self.gate.chunk_bits() + 1) @@ -481,14 +482,15 @@ mod tests { .zip(second_input_chunks.iter()) .map(|(f, s)| if *f == *s { F::ONE } else { F::ONE / (*f - *s) }) .collect(); - + let mut diff_index = 0; for i in 1..num_chunks { if first_input_chunks[i] != second_input_chunks[i] { diff_index = i; } } - let most_significant_diff = first_input_chunks[diff_index] - second_input_chunks[diff_index]; + let most_significant_diff = + first_input_chunks[diff_index] - second_input_chunks[diff_index]; let z = F::TWO.exp_u64(chunk_bits as u64) + most_significant_diff; let mut z_bits: Vec = (0..chunk_bits + 1) From 26c3edf4657112ddaf73a8e65c7a9a5753d40dde Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Tue, 14 Sep 2021 12:35:17 -0700 Subject: [PATCH 13/28] removed copies --- src/gates/comparison.rs | 256 ++++++++++++++++------------------------ 1 file changed, 103 insertions(+), 153 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 4f6186da..dbd2f941 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -16,16 +16,14 @@ use crate::util::{bits_u64, ceil_div_usize}; /// A gate for checking that one value is smaller than another. #[derive(Clone, Debug)] pub(crate) struct ComparisonGate, const D: usize> { - pub(crate) num_copies: usize, pub(crate) num_bits: usize, pub(crate) num_chunks: usize, _phantom: PhantomData, } impl, const D: usize> ComparisonGate { - pub fn new(num_copies: usize, num_bits: usize, num_chunks: usize) -> Self { + pub fn new(num_bits: usize, num_chunks: usize) -> Self { Self { - num_copies, num_bits, num_chunks, _phantom: PhantomData, @@ -36,62 +34,41 @@ impl, const D: usize> ComparisonGate { ceil_div_usize(self.num_bits, self.num_chunks) } - pub fn new_from_config(config: CircuitConfig, num_bits: usize, num_chunks: usize) -> Self { - let num_copies = Self::max_num_copies(config.num_routed_wires, num_bits, num_chunks); - Self::new(num_copies, num_bits, num_chunks) + pub fn wire_first_input(&self) -> usize { + 0 } - pub fn max_num_copies(num_routed_wires: usize, num_bits: usize, num_chunks: usize) -> usize { - let chunk_bits = ceil_div_usize(num_bits, num_chunks); - let wires_per_copy = 4 + chunk_bits + 4 * num_chunks; - num_routed_wires / wires_per_copy + pub fn wire_second_input(&self) -> usize { + 1 } - pub fn wires_per_copy(&self) -> usize { - 4 + self.chunk_bits() + 4 * self.num_chunks + pub fn wire_z_val(&self) -> usize { + 2 } - pub fn wire_first_input(&self, copy: usize) -> usize { - debug_assert!(copy < self.num_copies); - copy * self.wires_per_copy() - } - - pub fn wire_second_input(&self, copy: usize) -> usize { - debug_assert!(copy < self.num_copies); - copy * self.wires_per_copy() + 1 - } - - pub fn wire_z_val(&self, copy: usize) -> usize { - copy * self.wires_per_copy() + 2 - } - - pub fn wire_z_bit(&self, copy: usize, bit_index: usize) -> usize { + pub fn wire_z_bit(&self, bit_index: usize) -> usize { debug_assert!(bit_index < self.chunk_bits() + 1); - copy * self.wires_per_copy() + 3 + bit_index + 3 + bit_index } - pub fn wire_first_chunk_val(&self, copy: usize, chunk: usize) -> usize { - debug_assert!(copy < self.num_copies); + pub fn wire_first_chunk_val(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - copy * self.wires_per_copy() + 4 + self.chunk_bits() + chunk + 4 + self.chunk_bits() + chunk } - pub fn wire_second_chunk_val(&self, copy: usize, chunk: usize) -> usize { - debug_assert!(copy < self.num_copies); + pub fn wire_second_chunk_val(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - copy * self.wires_per_copy() + 4 + self.chunk_bits() + self.num_chunks + chunk + 4 + self.chunk_bits() + self.num_chunks + chunk } - pub fn wire_equality_dummy(&self, copy: usize, chunk: usize) -> usize { - debug_assert!(copy < self.num_copies); + pub fn wire_equality_dummy(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - copy * self.wires_per_copy() + 4 + self.chunk_bits() + 2 * self.num_chunks + chunk + 4 + self.chunk_bits() + 2 * self.num_chunks + chunk } - pub fn wire_chunks_equal(&self, copy: usize, chunk: usize) -> usize { - debug_assert!(copy < self.num_copies); + pub fn wire_chunks_equal(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - copy * self.wires_per_copy() + 4 + self.chunk_bits() + 3 * self.num_chunks + chunk + 4 + self.chunk_bits() + 3 * self.num_chunks + chunk } } @@ -103,72 +80,70 @@ impl, const D: usize> Gate for ComparisonGate fn eval_unfiltered(&self, vars: EvaluationVars) -> Vec { let mut constraints = Vec::with_capacity(self.num_constraints()); - for c in 0..self.num_copies { - let first_input = vars.local_wires[self.wire_first_input(c)]; - let second_input = vars.local_wires[self.wire_second_input(c)]; + let first_input = vars.local_wires[self.wire_first_input()]; + let second_input = vars.local_wires[self.wire_second_input()]; - // Get chunks and assert that they match - let first_chunks: Vec = (0..self.num_chunks) - .map(|i| vars.local_wires[self.wire_first_chunk_val(c, i)]) - .collect(); - let second_chunks: Vec = (0..self.num_chunks) - .map(|i| vars.local_wires[self.wire_second_chunk_val(c, i)]) - .collect(); + // Get chunks and assert that they match + let first_chunks: Vec = (0..self.num_chunks) + .map(|i| vars.local_wires[self.wire_first_chunk_val(i)]) + .collect(); + let second_chunks: Vec = (0..self.num_chunks) + .map(|i| vars.local_wires[self.wire_second_chunk_val(i)]) + .collect(); - let chunk_base_powers: Vec = (0..self.num_chunks) - .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits()) as u64)) - .collect(); + let chunk_base_powers: Vec = (0..self.num_chunks) + .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits()) as u64)) + .collect(); - let first_chunks_combined = first_chunks - .iter() - .zip(chunk_base_powers.iter()) - .map(|(b, x)| *b * *x) - .fold(F::Extension::ZERO, |a, b| a + b); - let second_chunks_combined = second_chunks - .iter() - .zip(chunk_base_powers.iter()) - .map(|(b, x)| *b * *x) - .fold(F::Extension::ZERO, |a, b| a + b); + let first_chunks_combined = first_chunks + .iter() + .zip(chunk_base_powers.iter()) + .map(|(b, x)| *b * *x) + .fold(F::Extension::ZERO, |a, b| a + b); + let second_chunks_combined = second_chunks + .iter() + .zip(chunk_base_powers.iter()) + .map(|(b, x)| *b * *x) + .fold(F::Extension::ZERO, |a, b| a + b); - constraints.push(first_chunks_combined - first_input); - constraints.push(second_chunks_combined - second_input); + constraints.push(first_chunks_combined - first_input); + constraints.push(second_chunks_combined - second_input); - let mut most_significant_diff = F::Extension::ZERO; + let mut most_significant_diff = F::Extension::ZERO; - // Find the chosen chunk. - for i in 0..self.num_chunks { - let difference = first_chunks[i] - second_chunks[i]; - let equality_dummy = vars.local_wires[self.wire_equality_dummy(c, i)]; - let chunks_equal = vars.local_wires[self.wire_chunks_equal(c, i)]; + // Find the chosen chunk. + for i in 0..self.num_chunks { + let difference = first_chunks[i] - second_chunks[i]; + let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; + let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; - // Two constraints identifying index. - constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); - constraints.push(chunks_equal * difference); + // Two constraints identifying index. + constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); + constraints.push(chunks_equal * difference); - let this_diff = first_chunks[i] - second_chunks[i]; - most_significant_diff = chunks_equal * most_significant_diff - + (F::Extension::ONE - chunks_equal) * this_diff; - } - - let z_bits: Vec = (0..self.chunk_bits() + 1) - .map(|i| vars.local_wires[self.wire_z_bit(c, i)]) - .collect(); - - let powers_of_two: Vec = (0..self.chunk_bits() + 1) - .map(|i| F::Extension::TWO.exp_u64(i as u64)) - .collect(); - let z_bits_combined = z_bits - .iter() - .zip(powers_of_two.iter()) - .map(|(b, x)| *b * *x) - .fold(F::Extension::ZERO, |a, b| a + b); - - let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); - constraints.push(z_bits_combined - (two_n + most_significant_diff)); - - //constraints.push(z_bits[self.chunk_bits() - 1]); + let this_diff = first_chunks[i] - second_chunks[i]; + most_significant_diff = chunks_equal * most_significant_diff + + (F::Extension::ONE - chunks_equal) * this_diff; } + let z_bits: Vec = (0..self.chunk_bits() + 1) + .map(|i| vars.local_wires[self.wire_z_bit(i)]) + .collect(); + + let powers_of_two: Vec = (0..self.chunk_bits() + 1) + .map(|i| F::Extension::TWO.exp_u64(i as u64)) + .collect(); + let z_bits_combined = z_bits + .iter() + .zip(powers_of_two.iter()) + .map(|(b, x)| *b * *x) + .fold(F::Extension::ZERO, |a, b| a + b); + + let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); + constraints.push(z_bits_combined - (two_n + most_significant_diff)); + + //constraints.push(z_bits[self.chunk_bits() - 1]); + constraints } @@ -189,21 +164,15 @@ impl, const D: usize> Gate for ComparisonGate gate_index: usize, _local_constants: &[F], ) -> Vec>> { - (0..self.num_copies) - .map(|c| { - let gen = ComparisonGenerator:: { - gate_index, - gate: self.clone(), - copy: c, - }; - let g: Box> = Box::new(gen.adapter()); - g - }) - .collect() + let gen = ComparisonGenerator:: { + gate_index, + gate: self.clone(), + }; + vec![Box::new(gen.adapter())] } fn num_wires(&self) -> usize { - self.wire_chunks_equal(self.num_copies - 1, self.num_chunks - 1) + 1 + self.wire_chunks_equal(self.num_chunks - 1) + 1 } fn num_constants(&self) -> usize { @@ -215,7 +184,7 @@ impl, const D: usize> Gate for ComparisonGate } fn num_constraints(&self) -> usize { - self.num_copies * (4 + 2 * self.num_chunks) + 4 + 2 * self.num_chunks } } @@ -223,7 +192,6 @@ impl, const D: usize> Gate for ComparisonGate struct ComparisonGenerator, const D: usize> { gate_index: usize, gate: ComparisonGate, - copy: usize, } impl, const D: usize> SimpleGenerator @@ -233,8 +201,8 @@ impl, const D: usize> SimpleGenerator let local_target = |input| Target::wire(self.gate_index, input); let mut deps = Vec::new(); - deps.push(local_target(self.gate.wire_first_input(self.copy))); - deps.push(local_target(self.gate.wire_second_input(self.copy))); + deps.push(local_target(self.gate.wire_first_input())); + deps.push(local_target(self.gate.wire_second_input())); deps } @@ -246,8 +214,8 @@ impl, const D: usize> SimpleGenerator let get_local_wire = |input| witness.get_wire(local_wire(input)); - let first_input = get_local_wire(self.gate.wire_first_input(self.copy)); - let second_input = get_local_wire(self.gate.wire_second_input(self.copy)); + let first_input = get_local_wire(self.gate.wire_first_input()); + let second_input = get_local_wire(self.gate.wire_second_input()); let first_input_u64 = first_input.to_canonical_u64(); let second_input_u64 = second_input.to_canonical_u64(); @@ -316,25 +284,22 @@ impl, const D: usize> SimpleGenerator }) .collect(); - out_buffer.set_wire(local_wire(self.gate.wire_z_val(self.copy)), z); + out_buffer.set_wire(local_wire(self.gate.wire_z_val()), z); for b in 0..self.gate.chunk_bits() + 1 { - out_buffer.set_wire(local_wire(self.gate.wire_z_bit(self.copy, b)), z_bits[b]); + out_buffer.set_wire(local_wire(self.gate.wire_z_bit(b)), z_bits[b]); } for i in 0..self.gate.num_chunks { out_buffer.set_wire( - local_wire(self.gate.wire_first_chunk_val(self.copy, i)), + 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(self.copy, i)), + local_wire(self.gate.wire_second_chunk_val(i)), second_input_chunks[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(self.copy, i)), - chunks_equal[i], - ); - out_buffer.set_wire( - local_wire(self.gate.wire_equality_dummy(self.copy, i)), + local_wire(self.gate.wire_equality_dummy(i)), equality_dummies[i], ); } @@ -362,33 +327,27 @@ mod tests { fn wire_indices() { type CG = ComparisonGate; let num_bits = 40; - let num_copies = 3; let num_chunks = 5; let gate = CG { num_bits, num_chunks, - num_copies, _phantom: PhantomData, }; - assert_eq!(gate.wire_first_input(0), 0); - assert_eq!(gate.wire_second_input(0), 1); - assert_eq!(gate.wire_z_val(0), 2); - assert_eq!(gate.wire_z_bit(0, 0), 3); - assert_eq!(gate.wire_z_bit(0, 8), 11); - assert_eq!(gate.wire_first_chunk_val(0, 0), 12); - assert_eq!(gate.wire_first_chunk_val(0, 4), 16); - assert_eq!(gate.wire_second_chunk_val(0, 0), 17); - assert_eq!(gate.wire_second_chunk_val(0, 4), 21); - assert_eq!(gate.wire_equality_dummy(0, 0), 22); - assert_eq!(gate.wire_equality_dummy(0, 4), 26); - assert_eq!(gate.wire_chunks_equal(0, 0), 27); - assert_eq!(gate.wire_chunks_equal(0, 4), 31); - assert_eq!(gate.wire_first_input(1), 32); - assert_eq!(gate.wire_chunks_equal(1, 4), 63); - assert_eq!(gate.wire_first_input(2), 64); - assert_eq!(gate.wire_chunks_equal(2, 4), 95); + assert_eq!(gate.wire_first_input(), 0); + assert_eq!(gate.wire_second_input(), 1); + assert_eq!(gate.wire_z_val(), 2); + assert_eq!(gate.wire_z_bit(0), 3); + assert_eq!(gate.wire_z_bit(8), 11); + assert_eq!(gate.wire_first_chunk_val(0), 12); + assert_eq!(gate.wire_first_chunk_val(4), 16); + assert_eq!(gate.wire_second_chunk_val(0), 17); + assert_eq!(gate.wire_second_chunk_val(4), 21); + assert_eq!(gate.wire_equality_dummy(0), 22); + assert_eq!(gate.wire_equality_dummy(4), 26); + assert_eq!(gate.wire_chunks_equal(0), 27); + assert_eq!(gate.wire_chunks_equal(4), 31); } #[test] @@ -396,11 +355,7 @@ mod tests { let num_bits = 40; let num_chunks = 5; - test_low_degree::(ComparisonGate::<_, 4>::new_from_config( - CircuitConfig::large_config(), - num_bits, - num_chunks, - )) + test_low_degree::(ComparisonGate::<_, 4>::new(num_bits, num_chunks)) } #[test] @@ -408,11 +363,7 @@ mod tests { let num_bits = 40; let num_chunks = 5; - test_eval_fns::(ComparisonGate::<_, 4>::new_from_config( - CircuitConfig::large_config(), - num_bits, - num_chunks, - )) + test_eval_fns::(ComparisonGate::<_, 4>::new(num_bits, num_chunks)) } #[test] @@ -524,7 +475,6 @@ mod tests { .collect(); let gate = ComparisonGate:: { - num_copies, num_bits, num_chunks, _phantom: PhantomData, From 8efa5a54b1a6c3dd94b64d5315a7d99f2c343fc2 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Tue, 14 Sep 2021 12:42:53 -0700 Subject: [PATCH 14/28] fixed test (first is actually smaller than second :P) --- src/gates/comparison.rs | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index dbd2f941..38ad9429 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -142,7 +142,7 @@ impl, const D: usize> Gate for ComparisonGate let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); constraints.push(z_bits_combined - (two_n + most_significant_diff)); - //constraints.push(z_bits[self.chunk_bits() - 1]); + constraints.push(z_bits[self.chunk_bits()]); constraints } @@ -467,12 +467,21 @@ mod tests { let mut rng = rand::thread_rng(); let max: u64 = 1 << num_bits - 1; - let first_inputs = (0..num_copies) - .map(|_| F::from_canonical_u64(rng.gen_range(0..max))) + let first_inputs_u64: Vec = (0..num_copies) + .map(|_| rng.gen_range(0..max)) .collect(); - let second_inputs = (0..num_copies) - .map(|_| F::from_canonical_u64(rng.gen_range(0..max))) + let second_inputs_u64: Vec = (0..num_copies) + .map(|i| { + let mut val = rng.gen_range(0..max); + while val <= first_inputs_u64[i] { + val = rng.gen_range(0..max); + } + val + }) .collect(); + + let first_inputs = first_inputs_u64.iter().map(|&x| F::from_canonical_u64(x)).collect(); + let second_inputs = second_inputs_u64.iter().map(|&x| F::from_canonical_u64(x)).collect(); let gate = ComparisonGate:: { num_bits, From 2f0ba9f98faacc682da8cc39ae82f510f8061d3a Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Tue, 14 Sep 2021 13:27:17 -0700 Subject: [PATCH 15/28] cleanup (references) --- src/gates/comparison.rs | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 38ad9429..850fa311 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -98,12 +98,12 @@ impl, const D: usize> Gate for ComparisonGate let first_chunks_combined = first_chunks .iter() .zip(chunk_base_powers.iter()) - .map(|(b, x)| *b * *x) + .map(|(&b, &x)| b * x) .fold(F::Extension::ZERO, |a, b| a + b); let second_chunks_combined = second_chunks .iter() .zip(chunk_base_powers.iter()) - .map(|(b, x)| *b * *x) + .map(|(&b, &x)| b * x) .fold(F::Extension::ZERO, |a, b| a + b); constraints.push(first_chunks_combined - first_input); @@ -136,7 +136,7 @@ impl, const D: usize> Gate for ComparisonGate let z_bits_combined = z_bits .iter() .zip(powers_of_two.iter()) - .map(|(b, x)| *b * *x) + .map(|(&b, &x)| b * x) .fold(F::Extension::ZERO, |a, b| a + b); let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); @@ -243,7 +243,7 @@ impl, const D: usize> SimpleGenerator .map(|bits| { bits.iter() .zip(powers_of_two.iter()) - .map(|(b, x)| *b * *x) + .map(|(&b, &x)| b * x) .fold(F::ZERO, |a, b| a + b) }) .collect(); @@ -252,7 +252,7 @@ impl, const D: usize> SimpleGenerator .map(|bits| { bits.iter() .zip(powers_of_two.iter()) - .map(|(b, x)| *b * *x) + .map(|(&b, &x)| b * x) .fold(F::ZERO, |a, b| a + b) }) .collect(); @@ -411,7 +411,7 @@ mod tests { .map(|bits| { bits.iter() .zip(powers_of_two.iter()) - .map(|(b, x)| *b * *x) + .map(|(&b, &x)| b * x) .fold(F::ZERO, |a, b| a + b) }) .collect(); @@ -420,7 +420,7 @@ mod tests { .map(|bits| { bits.iter() .zip(powers_of_two.iter()) - .map(|(b, x)| *b * *x) + .map(|(&b, &x)| b * x) .fold(F::ZERO, |a, b| a + b) }) .collect(); @@ -431,7 +431,7 @@ mod tests { let mut equality_dummies: Vec = first_input_chunks .iter() .zip(second_input_chunks.iter()) - .map(|(f, s)| if *f == *s { F::ONE } else { F::ONE / (*f - *s) }) + .map(|(&f, &s)| if f == s { F::ONE } else { F::ONE / (f - s) }) .collect(); let mut diff_index = 0; @@ -467,9 +467,7 @@ mod tests { let mut rng = rand::thread_rng(); let max: u64 = 1 << num_bits - 1; - let first_inputs_u64: Vec = (0..num_copies) - .map(|_| rng.gen_range(0..max)) - .collect(); + let first_inputs_u64: Vec = (0..num_copies).map(|_| rng.gen_range(0..max)).collect(); let second_inputs_u64: Vec = (0..num_copies) .map(|i| { let mut val = rng.gen_range(0..max); @@ -479,9 +477,15 @@ mod tests { val }) .collect(); - - let first_inputs = first_inputs_u64.iter().map(|&x| F::from_canonical_u64(x)).collect(); - let second_inputs = second_inputs_u64.iter().map(|&x| F::from_canonical_u64(x)).collect(); + + let first_inputs = first_inputs_u64 + .iter() + .map(|&x| F::from_canonical_u64(x)) + .collect(); + let second_inputs = second_inputs_u64 + .iter() + .map(|&x| F::from_canonical_u64(x)) + .collect(); let gate = ComparisonGate:: { num_bits, From 9fe6dab045c18f88e01189127e854cf4045113a3 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Tue, 14 Sep 2021 13:28:23 -0700 Subject: [PATCH 16/28] cleanup --- src/gates/comparison.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 850fa311..ab8e5751 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -320,7 +320,6 @@ 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::circuit_data::CircuitConfig; use crate::plonk::vars::EvaluationVars; #[test] From 1a1358c081f81f1019e4fa9239dedad9e84c1959 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Tue, 14 Sep 2021 14:24:15 -0700 Subject: [PATCH 17/28] cleanup (using reduce_with_powers) --- src/gates/comparison.rs | 70 ++++++++++------------------------------- 1 file changed, 16 insertions(+), 54 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index ab8e5751..d14b85cf 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -9,9 +9,9 @@ use crate::iop::target::Target; use crate::iop::wire::Wire; use crate::iop::witness::{PartitionWitness, Witness}; use crate::plonk::circuit_builder::CircuitBuilder; -use crate::plonk::circuit_data::CircuitConfig; +use crate::plonk::plonk_common::reduce_with_powers; use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase}; -use crate::util::{bits_u64, ceil_div_usize}; +use crate::util::ceil_div_usize; /// A gate for checking that one value is smaller than another. #[derive(Clone, Debug)] @@ -91,20 +91,14 @@ impl, const D: usize> Gate for ComparisonGate .map(|i| vars.local_wires[self.wire_second_chunk_val(i)]) .collect(); - let chunk_base_powers: Vec = (0..self.num_chunks) - .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits()) as u64)) - .collect(); - - let first_chunks_combined = first_chunks - .iter() - .zip(chunk_base_powers.iter()) - .map(|(&b, &x)| b * x) - .fold(F::Extension::ZERO, |a, b| a + b); - let second_chunks_combined = second_chunks - .iter() - .zip(chunk_base_powers.iter()) - .map(|(&b, &x)| b * x) - .fold(F::Extension::ZERO, |a, b| a + b); + let first_chunks_combined = reduce_with_powers( + &first_chunks, + F::Extension::from_canonical_usize(1 << self.chunk_bits()), + ); + let second_chunks_combined = reduce_with_powers( + &second_chunks, + F::Extension::from_canonical_usize(1 << self.chunk_bits()), + ); constraints.push(first_chunks_combined - first_input); constraints.push(second_chunks_combined - second_input); @@ -129,15 +123,7 @@ impl, const D: usize> Gate for ComparisonGate let z_bits: Vec = (0..self.chunk_bits() + 1) .map(|i| vars.local_wires[self.wire_z_bit(i)]) .collect(); - - let powers_of_two: Vec = (0..self.chunk_bits() + 1) - .map(|i| F::Extension::TWO.exp_u64(i as u64)) - .collect(); - let z_bits_combined = z_bits - .iter() - .zip(powers_of_two.iter()) - .map(|(&b, &x)| b * x) - .fold(F::Extension::ZERO, |a, b| a + b); + let z_bits_combined: F::Extension = reduce_with_powers(&z_bits, F::Extension::TWO); let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); constraints.push(z_bits_combined - (two_n + most_significant_diff)); @@ -235,26 +221,13 @@ impl, const D: usize> SimpleGenerator }) .collect(); - let powers_of_two: Vec = (0..self.gate.chunk_bits()) - .map(|i| F::TWO.exp_u64(i as u64)) - .collect(); let first_input_chunks: Vec = first_input_bits .chunks(self.gate.chunk_bits()) - .map(|bits| { - bits.iter() - .zip(powers_of_two.iter()) - .map(|(&b, &x)| b * x) - .fold(F::ZERO, |a, b| a + b) - }) + .map(|bits| reduce_with_powers(&bits, F::TWO)) .collect(); let second_input_chunks: Vec = second_input_bits .chunks(self.gate.chunk_bits()) - .map(|bits| { - bits.iter() - .zip(powers_of_two.iter()) - .map(|(&b, &x)| b * x) - .fold(F::ZERO, |a, b| a + b) - }) + .map(|bits| reduce_with_powers(&bits, F::TWO)) .collect(); let chunks_equal: Vec = (0..self.gate.num_chunks) @@ -320,6 +293,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::plonk_common::reduce_with_powers; use crate::plonk::vars::EvaluationVars; #[test] @@ -403,25 +377,13 @@ mod tests { }) .collect(); - let powers_of_two: Vec = - (0..chunk_bits).map(|i| F::TWO.exp_u64(i as u64)).collect(); let mut first_input_chunks: Vec = first_input_bits .chunks(chunk_bits) - .map(|bits| { - bits.iter() - .zip(powers_of_two.iter()) - .map(|(&b, &x)| b * x) - .fold(F::ZERO, |a, b| a + b) - }) + .map(|bits| reduce_with_powers(&bits, F::TWO)) .collect(); let mut second_input_chunks: Vec = second_input_bits .chunks(chunk_bits) - .map(|bits| { - bits.iter() - .zip(powers_of_two.iter()) - .map(|(&b, &x)| b * x) - .fold(F::ZERO, |a, b| a + b) - }) + .map(|bits| reduce_with_powers(&bits, F::TWO)) .collect(); let mut chunks_equal: Vec = (0..num_chunks) From 8a4259cc28cd25d48f751d8cd9418a23c8e82a5e Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Tue, 14 Sep 2021 14:26:04 -0700 Subject: [PATCH 18/28] addressed comments --- src/gates/comparison.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index d14b85cf..38c8dea4 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -206,6 +206,8 @@ impl, const D: usize> SimpleGenerator let first_input_u64 = first_input.to_canonical_u64(); let second_input_u64 = second_input.to_canonical_u64(); + debug_assert!(first_input_u64 < second_input_u64); + let first_input_bits: Vec = (0..self.gate.num_bits) .scan(first_input_u64, |acc, _| { let tmp = *acc % 2; From 806f4af92cc70f227eeb23f4ee2641e00b12352f Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Tue, 14 Sep 2021 14:53:33 -0700 Subject: [PATCH 19/28] eval_unfiltered_base --- src/gates/comparison.rs | 56 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 54 insertions(+), 2 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 38c8dea4..edf8ca9c 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -123,7 +123,7 @@ impl, const D: usize> Gate for ComparisonGate let z_bits: Vec = (0..self.chunk_bits() + 1) .map(|i| vars.local_wires[self.wire_z_bit(i)]) .collect(); - let z_bits_combined: F::Extension = reduce_with_powers(&z_bits, F::Extension::TWO); + let z_bits_combined = reduce_with_powers(&z_bits, F::Extension::TWO); let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); constraints.push(z_bits_combined - (two_n + most_significant_diff)); @@ -134,7 +134,59 @@ impl, const D: usize> Gate for ComparisonGate } fn eval_unfiltered_base(&self, vars: EvaluationVarsBase) -> Vec { - todo!() + let mut constraints = Vec::with_capacity(self.num_constraints()); + + let first_input = vars.local_wires[self.wire_first_input()]; + let second_input = vars.local_wires[self.wire_second_input()]; + + // Get chunks and assert that they match + let first_chunks: Vec = (0..self.num_chunks) + .map(|i| vars.local_wires[self.wire_first_chunk_val(i)]) + .collect(); + let second_chunks: Vec = (0..self.num_chunks) + .map(|i| vars.local_wires[self.wire_second_chunk_val(i)]) + .collect(); + + let first_chunks_combined = reduce_with_powers( + &first_chunks, + F::from_canonical_usize(1 << self.chunk_bits()), + ); + let second_chunks_combined = reduce_with_powers( + &second_chunks, + F::from_canonical_usize(1 << self.chunk_bits()), + ); + + constraints.push(first_chunks_combined - first_input); + constraints.push(second_chunks_combined - second_input); + + let mut most_significant_diff = F::ZERO; + + // Find the chosen chunk. + for i in 0..self.num_chunks { + let difference = first_chunks[i] - second_chunks[i]; + let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; + let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; + + // Two constraints identifying index. + constraints.push(difference * equality_dummy - (F::ONE - chunks_equal)); + constraints.push(chunks_equal * difference); + + let this_diff = first_chunks[i] - second_chunks[i]; + most_significant_diff = + chunks_equal * most_significant_diff + (F::ONE - chunks_equal) * this_diff; + } + + let z_bits: Vec = (0..self.chunk_bits() + 1) + .map(|i| vars.local_wires[self.wire_z_bit(i)]) + .collect(); + let z_bits_combined = reduce_with_powers(&z_bits, F::TWO); + + let two_n = F::TWO.exp_u64(self.chunk_bits() as u64); + constraints.push(z_bits_combined - (two_n + most_significant_diff)); + + constraints.push(z_bits[self.chunk_bits()]); + + constraints } fn eval_unfiltered_recursively( From a68094d37882b336435707e1d03431087db6bfe8 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Tue, 14 Sep 2021 15:13:26 -0700 Subject: [PATCH 20/28] eval_unfiltered_recusively --- src/gates/comparison.rs | 61 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 59 insertions(+), 2 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index edf8ca9c..86abd51b 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -9,7 +9,7 @@ use crate::iop::target::Target; use crate::iop::wire::Wire; use crate::iop::witness::{PartitionWitness, Witness}; use crate::plonk::circuit_builder::CircuitBuilder; -use crate::plonk::plonk_common::reduce_with_powers; +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; @@ -194,7 +194,64 @@ impl, const D: usize> Gate for ComparisonGate builder: &mut CircuitBuilder, vars: EvaluationTargets, ) -> Vec> { - todo!() + let mut constraints = Vec::with_capacity(self.num_constraints()); + + let first_input = vars.local_wires[self.wire_first_input()]; + let second_input = vars.local_wires[self.wire_second_input()]; + + // Get chunks and assert that they match + let first_chunks: Vec> = (0..self.num_chunks) + .map(|i| vars.local_wires[self.wire_first_chunk_val(i)]) + .collect(); + let second_chunks: Vec> = (0..self.num_chunks) + .map(|i| vars.local_wires[self.wire_second_chunk_val(i)]) + .collect(); + + let chunk_base = builder.constant(F::from_canonical_usize(1 << self.chunk_bits())); + let first_chunks_combined = + reduce_with_powers_ext_recursive(builder, &first_chunks, chunk_base); + let second_chunks_combined = + reduce_with_powers_ext_recursive(builder, &second_chunks, chunk_base); + + constraints.push(builder.sub_extension(first_chunks_combined, first_input)); + constraints.push(builder.sub_extension(second_chunks_combined, second_input)); + + let mut most_significant_diff = builder.zero_extension(); + + let one = builder.one_extension(); + // Find the chosen chunk. + for i in 0..self.num_chunks { + let difference = builder.sub_extension(first_chunks[i], second_chunks[i]); + let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; + let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; + + // Two constraints identifying index. + let diff_times_equal = builder.mul_extension(difference, equality_dummy); + let not_equal = builder.sub_extension(one, chunks_equal); + constraints.push(builder.sub_extension(diff_times_equal, not_equal)); + constraints.push(builder.mul_extension(chunks_equal, difference)); + + let this_diff = builder.sub_extension(first_chunks[i], second_chunks[i]); + let old_diff = builder.mul_extension(chunks_equal, most_significant_diff); + let not_equal = builder.sub_extension(one, chunks_equal); + let new_diff = builder.mul_extension(not_equal, this_diff); + most_significant_diff = builder.add_extension(old_diff, new_diff); + } + + let two = builder.constant(F::TWO); + let z_bits: Vec> = (0..self.chunk_bits() + 1) + .map(|i| vars.local_wires[self.wire_z_bit(i)]) + .collect(); + let z_bits_combined = reduce_with_powers_ext_recursive(builder, &z_bits, two); + + let two_n = builder.constant_extension(F::Extension::TWO.exp_u64(self.chunk_bits() as u64)); + let expected_z = builder.add_extension(two_n, most_significant_diff); + let z_diff = builder.sub_extension(z_bits_combined, expected_z); + constraints.push(z_diff); + + constraints.push(z_bits[self.chunk_bits()]); + + constraints } fn generators( From 677165fda76d478bfc4d6ddaacd957e2aa30744a Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Wed, 15 Sep 2021 14:40:28 -0700 Subject: [PATCH 21/28] range check of chunks --- src/gates/comparison.rs | 39 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 37 insertions(+), 2 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 86abd51b..2e79bc72 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -107,6 +107,17 @@ impl, const D: usize> Gate for ComparisonGate // Find the chosen chunk. for i in 0..self.num_chunks { + let max_chunk_size = 1 << self.chunk_bits(); + let mut first_product = F::Extension::ONE; + let mut second_product = F::Extension::ONE; + for x in 1..max_chunk_size { + let x_F = F::Extension::from_canonical_usize(x); + first_product = first_product * (first_chunks[i] - x_F); + second_product = second_product * (second_chunks[i] - x_F); + } + constraints.push(first_product); + constraints.push(second_product); + let difference = first_chunks[i] - second_chunks[i]; let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; @@ -163,6 +174,17 @@ impl, const D: usize> Gate for ComparisonGate // Find the chosen chunk. for i in 0..self.num_chunks { + let max_chunk_size = 1 << self.chunk_bits(); + let mut first_product = F::ONE; + let mut second_product = F::ONE; + for x in 1..max_chunk_size { + let x_F = F::from_canonical_usize(x); + first_product = first_product * (first_chunks[i] - x_F); + second_product = second_product * (second_chunks[i] - x_F); + } + constraints.push(first_product); + constraints.push(second_product); + let difference = first_chunks[i] - second_chunks[i]; let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; @@ -221,6 +243,19 @@ impl, const D: usize> Gate for ComparisonGate let one = builder.one_extension(); // Find the chosen chunk. for i in 0..self.num_chunks { + let max_chunk_size = 1 << self.chunk_bits(); + let mut first_product = one; + let mut second_product = one; + for x in 1..max_chunk_size { + let x_F = builder.constant_extension(F::Extension::from_canonical_usize(x)); + let first_diff = builder.sub_extension(first_chunks[i], x_F); + let second_diff = builder.sub_extension(second_chunks[i], x_F); + first_product = builder.mul_extension(first_product, first_diff); + second_product = builder.mul_extension(second_product, second_diff); + } + constraints.push(first_product); + constraints.push(second_product); + let difference = builder.sub_extension(first_chunks[i], second_chunks[i]); let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; @@ -275,11 +310,11 @@ impl, const D: usize> Gate for ComparisonGate } fn degree(&self) -> usize { - self.num_chunks + 1 + (self.num_chunks + 1).max(1 << self.chunk_bits()) } fn num_constraints(&self) -> usize { - 4 + 2 * self.num_chunks + 4 + 4 * self.num_chunks } } From 44dc1cd4edbff4dec57ff60a24e47958c41bfe81 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Wed, 15 Sep 2021 14:46:44 -0700 Subject: [PATCH 22/28] removed z --- src/gates/comparison.rs | 37 +++++++++++++++---------------------- 1 file changed, 15 insertions(+), 22 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 2e79bc72..8b8a5da4 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -42,33 +42,29 @@ impl, const D: usize> ComparisonGate { 1 } - pub fn wire_z_val(&self) -> usize { - 2 - } - pub fn wire_z_bit(&self, bit_index: usize) -> usize { debug_assert!(bit_index < self.chunk_bits() + 1); - 3 + bit_index + 2 + bit_index } pub fn wire_first_chunk_val(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - 4 + self.chunk_bits() + chunk + 3 + self.chunk_bits() + chunk } pub fn wire_second_chunk_val(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - 4 + self.chunk_bits() + self.num_chunks + chunk + 3 + self.chunk_bits() + self.num_chunks + chunk } pub fn wire_equality_dummy(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - 4 + self.chunk_bits() + 2 * self.num_chunks + chunk + 3 + self.chunk_bits() + 2 * self.num_chunks + chunk } pub fn wire_chunks_equal(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - 4 + self.chunk_bits() + 3 * self.num_chunks + chunk + 3 + self.chunk_bits() + 3 * self.num_chunks + chunk } } @@ -403,7 +399,6 @@ impl, const D: usize> SimpleGenerator }) .collect(); - out_buffer.set_wire(local_wire(self.gate.wire_z_val()), z); for b in 0..self.gate.chunk_bits() + 1 { out_buffer.set_wire(local_wire(self.gate.wire_z_bit(b)), z_bits[b]); } @@ -456,17 +451,16 @@ mod tests { assert_eq!(gate.wire_first_input(), 0); assert_eq!(gate.wire_second_input(), 1); - assert_eq!(gate.wire_z_val(), 2); - assert_eq!(gate.wire_z_bit(0), 3); - assert_eq!(gate.wire_z_bit(8), 11); - assert_eq!(gate.wire_first_chunk_val(0), 12); - assert_eq!(gate.wire_first_chunk_val(4), 16); - assert_eq!(gate.wire_second_chunk_val(0), 17); - assert_eq!(gate.wire_second_chunk_val(4), 21); - assert_eq!(gate.wire_equality_dummy(0), 22); - assert_eq!(gate.wire_equality_dummy(4), 26); - assert_eq!(gate.wire_chunks_equal(0), 27); - assert_eq!(gate.wire_chunks_equal(4), 31); + assert_eq!(gate.wire_z_bit(0), 2); + assert_eq!(gate.wire_z_bit(8), 10); + assert_eq!(gate.wire_first_chunk_val(0), 11); + assert_eq!(gate.wire_first_chunk_val(4), 15); + assert_eq!(gate.wire_second_chunk_val(0), 16); + assert_eq!(gate.wire_second_chunk_val(4), 20); + assert_eq!(gate.wire_equality_dummy(0), 21); + assert_eq!(gate.wire_equality_dummy(4), 25); + assert_eq!(gate.wire_chunks_equal(0), 26); + assert_eq!(gate.wire_chunks_equal(4), 30); } #[test] @@ -561,7 +555,6 @@ mod tests { v.push(first_input); v.push(second_input); - v.push(z); v.append(&mut z_bits); v.append(&mut first_input_chunks); v.append(&mut second_input_chunks); From c207a028520598f88b701b4093f6663af4060ce1 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Wed, 15 Sep 2021 16:41:29 -0700 Subject: [PATCH 23/28] changes and fixes (z --> most_significant_diff) --- src/gates/comparison.rs | 287 ++++++++++++++++++---------------------- 1 file changed, 127 insertions(+), 160 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 8b8a5da4..9e8393f1 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -42,29 +42,28 @@ impl, const D: usize> ComparisonGate { 1 } - pub fn wire_z_bit(&self, bit_index: usize) -> usize { - debug_assert!(bit_index < self.chunk_bits() + 1); - 2 + bit_index + pub fn wire_most_significant_diff(&self) -> usize { + 2 } pub fn wire_first_chunk_val(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - 3 + self.chunk_bits() + chunk + 3 + chunk } pub fn wire_second_chunk_val(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - 3 + self.chunk_bits() + self.num_chunks + chunk + 3 + self.num_chunks + chunk } pub fn wire_equality_dummy(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - 3 + self.chunk_bits() + 2 * self.num_chunks + chunk + 3 + 2 * self.num_chunks + chunk } pub fn wire_chunks_equal(&self, chunk: usize) -> usize { debug_assert!(chunk < self.num_chunks); - 3 + self.chunk_bits() + 3 * self.num_chunks + chunk + 3 + 3 * self.num_chunks + chunk } } @@ -99,14 +98,15 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_chunks_combined - first_input); constraints.push(second_chunks_combined - second_input); - let mut most_significant_diff = F::Extension::ZERO; + let max_chunk_size = 1 << self.chunk_bits(); + + let mut most_significant_diff_so_far = F::Extension::ZERO; // Find the chosen chunk. for i in 0..self.num_chunks { - let max_chunk_size = 1 << self.chunk_bits(); let mut first_product = F::Extension::ONE; let mut second_product = F::Extension::ONE; - for x in 1..max_chunk_size { + for x in 0..max_chunk_size { let x_F = F::Extension::from_canonical_usize(x); first_product = first_product * (first_chunks[i] - x_F); second_product = second_product * (second_chunks[i] - x_F); @@ -114,7 +114,7 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_product); constraints.push(second_product); - let difference = first_chunks[i] - second_chunks[i]; + let difference = second_chunks[i] - first_chunks[i]; let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; @@ -122,20 +122,21 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); constraints.push(chunks_equal * difference); - let this_diff = first_chunks[i] - second_chunks[i]; - most_significant_diff = chunks_equal * most_significant_diff + let this_diff = second_chunks[i] - first_chunks[i]; + most_significant_diff_so_far = chunks_equal * most_significant_diff_so_far + (F::Extension::ONE - chunks_equal) * this_diff; } - let z_bits: Vec = (0..self.chunk_bits() + 1) - .map(|i| vars.local_wires[self.wire_z_bit(i)]) - .collect(); - let z_bits_combined = reduce_with_powers(&z_bits, F::Extension::TWO); + let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; + constraints.push(most_significant_diff - most_significant_diff_so_far); - let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64); - constraints.push(z_bits_combined - (two_n + most_significant_diff)); - - constraints.push(z_bits[self.chunk_bits()]); + // Range check + let mut product = F::Extension::ONE; + for x in 0..max_chunk_size { + let x_F = F::Extension::from_canonical_usize(x); + product = product * (most_significant_diff - x_F); + } + constraints.push(product); constraints } @@ -166,14 +167,15 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_chunks_combined - first_input); constraints.push(second_chunks_combined - second_input); - let mut most_significant_diff = F::ZERO; + let max_chunk_size = 1 << self.chunk_bits(); + + let mut most_significant_diff_so_far = F::ZERO; // Find the chosen chunk. for i in 0..self.num_chunks { - let max_chunk_size = 1 << self.chunk_bits(); let mut first_product = F::ONE; let mut second_product = F::ONE; - for x in 1..max_chunk_size { + for x in 0..max_chunk_size { let x_F = F::from_canonical_usize(x); first_product = first_product * (first_chunks[i] - x_F); second_product = second_product * (second_chunks[i] - x_F); @@ -190,19 +192,20 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(chunks_equal * difference); let this_diff = first_chunks[i] - second_chunks[i]; - most_significant_diff = - chunks_equal * most_significant_diff + (F::ONE - chunks_equal) * this_diff; + most_significant_diff_so_far = + chunks_equal * most_significant_diff_so_far + (F::ONE - chunks_equal) * this_diff; } - let z_bits: Vec = (0..self.chunk_bits() + 1) - .map(|i| vars.local_wires[self.wire_z_bit(i)]) - .collect(); - let z_bits_combined = reduce_with_powers(&z_bits, F::TWO); + let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; + constraints.push(most_significant_diff - most_significant_diff_so_far); - let two_n = F::TWO.exp_u64(self.chunk_bits() as u64); - constraints.push(z_bits_combined - (two_n + most_significant_diff)); - - constraints.push(z_bits[self.chunk_bits()]); + // Range check + let mut product = F::ONE; + for x in 0..max_chunk_size { + let x_F = F::from_canonical_usize(x); + product = product * (most_significant_diff - x_F); + } + constraints.push(product); constraints } @@ -234,15 +237,16 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(builder.sub_extension(first_chunks_combined, first_input)); constraints.push(builder.sub_extension(second_chunks_combined, second_input)); - let mut most_significant_diff = builder.zero_extension(); + let max_chunk_size = 1 << self.chunk_bits(); + + let mut most_significant_diff_so_far = builder.zero_extension(); let one = builder.one_extension(); // Find the chosen chunk. for i in 0..self.num_chunks { - let max_chunk_size = 1 << self.chunk_bits(); let mut first_product = one; let mut second_product = one; - for x in 1..max_chunk_size { + for x in 0..max_chunk_size { let x_F = builder.constant_extension(F::Extension::from_canonical_usize(x)); let first_diff = builder.sub_extension(first_chunks[i], x_F); let second_diff = builder.sub_extension(second_chunks[i], x_F); @@ -252,7 +256,7 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_product); constraints.push(second_product); - let difference = builder.sub_extension(first_chunks[i], second_chunks[i]); + let difference = builder.sub_extension(second_chunks[i], first_chunks[i]); let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; @@ -262,25 +266,24 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(builder.sub_extension(diff_times_equal, not_equal)); constraints.push(builder.mul_extension(chunks_equal, difference)); - let this_diff = builder.sub_extension(first_chunks[i], second_chunks[i]); - let old_diff = builder.mul_extension(chunks_equal, most_significant_diff); + let this_diff = builder.sub_extension(second_chunks[i], first_chunks[i]); + let old_diff = builder.mul_extension(chunks_equal, most_significant_diff_so_far); let not_equal = builder.sub_extension(one, chunks_equal); let new_diff = builder.mul_extension(not_equal, this_diff); - most_significant_diff = builder.add_extension(old_diff, new_diff); + most_significant_diff_so_far = builder.add_extension(old_diff, new_diff); } - let two = builder.constant(F::TWO); - let z_bits: Vec> = (0..self.chunk_bits() + 1) - .map(|i| vars.local_wires[self.wire_z_bit(i)]) - .collect(); - let z_bits_combined = reduce_with_powers_ext_recursive(builder, &z_bits, two); + let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; + constraints.push(builder.sub_extension(most_significant_diff, most_significant_diff_so_far)); - let two_n = builder.constant_extension(F::Extension::TWO.exp_u64(self.chunk_bits() as u64)); - let expected_z = builder.add_extension(two_n, most_significant_diff); - let z_diff = builder.sub_extension(z_bits_combined, expected_z); - constraints.push(z_diff); - - constraints.push(z_bits[self.chunk_bits()]); + // Range check + let mut product = builder.one_extension(); + for x in 0..max_chunk_size { + let x_F = builder.constant_extension(F::Extension::from_canonical_usize(x)); + let diff = builder.sub_extension(most_significant_diff, x_F); + product = builder.mul_extension(product, diff); + } + constraints.push(product); constraints } @@ -378,7 +381,7 @@ impl, const D: usize> SimpleGenerator let equality_dummies: Vec = first_input_chunks .iter() .zip(second_input_chunks.iter()) - .map(|(f, s)| if *f == *s { F::ONE } else { F::ONE / (*f - *s) }) + .map(|(&f, &s)| if f == s { F::ONE } else { F::ONE / (s - f) }) .collect(); let mut diff_index = 0; @@ -387,21 +390,10 @@ impl, const D: usize> SimpleGenerator diff_index = i; } } - let most_significant_diff = - first_input_chunks[diff_index] - second_input_chunks[diff_index]; + + let most_significant_diff = second_input_chunks[diff_index] - first_input_chunks[diff_index]; - let z = F::TWO.exp_u64(self.gate.chunk_bits() as u64) + most_significant_diff; - let z_bits: Vec = (0..self.gate.chunk_bits() + 1) - .scan(z.to_canonical_u64(), |acc, _| { - let tmp = *acc % 2; - *acc /= 2; - Some(F::from_canonical_u64(tmp)) - }) - .collect(); - - for b in 0..self.gate.chunk_bits() + 1 { - out_buffer.set_wire(local_wire(self.gate.wire_z_bit(b)), z_bits[b]); - } + 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)), @@ -411,11 +403,11 @@ impl, const D: usize> SimpleGenerator local_wire(self.gate.wire_second_chunk_val(i)), second_input_chunks[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_equality_dummy(i)), equality_dummies[i], ); + out_buffer.set_wire(local_wire(self.gate.wire_chunks_equal(i)), chunks_equal[i]); } } } @@ -451,16 +443,15 @@ mod tests { assert_eq!(gate.wire_first_input(), 0); assert_eq!(gate.wire_second_input(), 1); - assert_eq!(gate.wire_z_bit(0), 2); - assert_eq!(gate.wire_z_bit(8), 10); - assert_eq!(gate.wire_first_chunk_val(0), 11); - assert_eq!(gate.wire_first_chunk_val(4), 15); - assert_eq!(gate.wire_second_chunk_val(0), 16); - assert_eq!(gate.wire_second_chunk_val(4), 20); - assert_eq!(gate.wire_equality_dummy(0), 21); - assert_eq!(gate.wire_equality_dummy(4), 25); - assert_eq!(gate.wire_chunks_equal(0), 26); - assert_eq!(gate.wire_chunks_equal(4), 30); + assert_eq!(gate.wire_most_significant_diff(), 2); + assert_eq!(gate.wire_first_chunk_val(0), 3); + assert_eq!(gate.wire_first_chunk_val(4), 7); + assert_eq!(gate.wire_second_chunk_val(0), 8); + assert_eq!(gate.wire_second_chunk_val(4), 12); + assert_eq!(gate.wire_equality_dummy(0), 13); + assert_eq!(gate.wire_equality_dummy(4), 17); + assert_eq!(gate.wire_chunks_equal(0), 18); + assert_eq!(gate.wire_chunks_equal(4), 22); } #[test] @@ -485,107 +476,83 @@ mod tests { type FF = QuarticExtension; const D: usize = 4; - let num_copies = 3; let num_bits = 40; let num_chunks = 5; let chunk_bits = num_bits / num_chunks; // Returns the local wires for a comparison gate given the two inputs. - let get_wires = |first_inputs: Vec, second_inputs: Vec| -> Vec { - let num_copies = first_inputs.len(); - + let get_wires = |first_input: F, second_input: F| -> Vec { let mut v = Vec::new(); - for c in 0..num_copies { - let first_input = first_inputs[c]; - let second_input = second_inputs[c]; - let first_input_u64 = first_input.to_canonical_u64(); - let second_input_u64 = second_input.to_canonical_u64(); + let first_input_u64 = first_input.to_canonical_u64(); + let second_input_u64 = second_input.to_canonical_u64(); - let first_input_bits: Vec = (0..num_bits) - .scan(first_input_u64, |acc, _| { - let tmp = *acc % 2; - *acc /= 2; - Some(F::from_canonical_u64(tmp)) - }) - .collect(); - let second_input_bits: Vec = (0..num_bits) - .scan(second_input_u64, |acc, _| { - let tmp = *acc % 2; - *acc /= 2; - Some(F::from_canonical_u64(tmp)) - }) - .collect(); + let first_input_bits: Vec = (0..num_bits) + .scan(first_input_u64, |acc, _| { + let tmp = *acc % 2; + *acc /= 2; + Some(F::from_canonical_u64(tmp)) + }) + .collect(); + let second_input_bits: Vec = (0..num_bits) + .scan(second_input_u64, |acc, _| { + let tmp = *acc % 2; + *acc /= 2; + Some(F::from_canonical_u64(tmp)) + }) + .collect(); - let mut first_input_chunks: Vec = first_input_bits - .chunks(chunk_bits) - .map(|bits| reduce_with_powers(&bits, F::TWO)) - .collect(); - let mut second_input_chunks: Vec = second_input_bits - .chunks(chunk_bits) - .map(|bits| reduce_with_powers(&bits, F::TWO)) - .collect(); + let mut first_input_chunks: Vec = first_input_bits + .chunks(chunk_bits) + .map(|bits| reduce_with_powers(&bits, F::TWO)) + .collect(); + let mut second_input_chunks: Vec = second_input_bits + .chunks(chunk_bits) + .map(|bits| reduce_with_powers(&bits, F::TWO)) + .collect(); - let mut chunks_equal: Vec = (0..num_chunks) - .map(|i| F::from_bool(first_input_chunks[i] == second_input_chunks[i])) - .collect(); - let mut equality_dummies: Vec = first_input_chunks - .iter() - .zip(second_input_chunks.iter()) - .map(|(&f, &s)| if f == s { F::ONE } else { F::ONE / (f - s) }) - .collect(); + let mut chunks_equal: Vec = (0..num_chunks) + .map(|i| F::from_bool(first_input_chunks[i] == second_input_chunks[i])) + .collect(); + let mut equality_dummies: Vec = first_input_chunks + .iter() + .zip(second_input_chunks.iter()) + .map(|(&f, &s)| if f == s { F::ONE } else { F::ONE / (s - f) }) + .collect(); - let mut diff_index = 0; - for i in 1..num_chunks { - if first_input_chunks[i] != second_input_chunks[i] { - diff_index = i; - } + let mut diff_index = 0; + for i in 1..num_chunks { + if first_input_chunks[i] != second_input_chunks[i] { + diff_index = i; } - let most_significant_diff = - first_input_chunks[diff_index] - second_input_chunks[diff_index]; - - let z = F::TWO.exp_u64(chunk_bits as u64) + most_significant_diff; - let mut z_bits: Vec = (0..chunk_bits + 1) - .scan(z.to_canonical_u64(), |acc, _| { - let tmp = *acc % 2; - *acc /= 2; - Some(F::from_canonical_u64(tmp)) - }) - .collect(); - - v.push(first_input); - v.push(second_input); - v.append(&mut z_bits); - v.append(&mut first_input_chunks); - v.append(&mut second_input_chunks); - v.append(&mut equality_dummies); - v.append(&mut chunks_equal); } + let most_significant_diff = second_input_chunks[diff_index] - first_input_chunks[diff_index]; + + v.push(first_input); + v.push(second_input); + v.push(most_significant_diff); + v.append(&mut first_input_chunks); + v.append(&mut second_input_chunks); + v.append(&mut equality_dummies); + v.append(&mut chunks_equal); + v.iter().map(|&x| x.into()).collect::>() }; let mut rng = rand::thread_rng(); let max: u64 = 1 << num_bits - 1; - let first_inputs_u64: Vec = (0..num_copies).map(|_| rng.gen_range(0..max)).collect(); - let second_inputs_u64: Vec = (0..num_copies) - .map(|i| { - let mut val = rng.gen_range(0..max); - while val <= first_inputs_u64[i] { - val = rng.gen_range(0..max); - } - val - }) - .collect(); + let first_input_u64 = rng.gen_range(0..max); + let second_input_u64 = { + let mut val = rng.gen_range(0..max); + while val <= first_input_u64 { + val = rng.gen_range(0..max); + } + val + }; - let first_inputs = first_inputs_u64 - .iter() - .map(|&x| F::from_canonical_u64(x)) - .collect(); - let second_inputs = second_inputs_u64 - .iter() - .map(|&x| F::from_canonical_u64(x)) - .collect(); + let first_input = F::from_canonical_u64(first_input_u64); + let second_input = F::from_canonical_u64(second_input_u64); let gate = ComparisonGate:: { num_bits, @@ -595,7 +562,7 @@ mod tests { let vars = EvaluationVars { local_constants: &[], - local_wires: &get_wires(first_inputs, second_inputs), + local_wires: &get_wires(first_input, second_input), public_inputs_hash: &HashOut::rand(), }; From 7a7bf371eb77218c6f3962bd65b4b932c6c105fc Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Wed, 15 Sep 2021 16:41:37 -0700 Subject: [PATCH 24/28] fmt --- src/gates/comparison.rs | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 9e8393f1..d8a0735f 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -274,7 +274,8 @@ impl, const D: usize> Gate for ComparisonGate } let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; - constraints.push(builder.sub_extension(most_significant_diff, most_significant_diff_so_far)); + constraints + .push(builder.sub_extension(most_significant_diff, most_significant_diff_so_far)); // Range check let mut product = builder.one_extension(); @@ -390,10 +391,14 @@ impl, const D: usize> SimpleGenerator diff_index = i; } } - - let most_significant_diff = second_input_chunks[diff_index] - first_input_chunks[diff_index]; - out_buffer.set_wire(local_wire(self.gate.wire_most_significant_diff()), most_significant_diff); + let most_significant_diff = + second_input_chunks[diff_index] - first_input_chunks[diff_index]; + + 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)), @@ -527,7 +532,8 @@ mod tests { } } - let most_significant_diff = second_input_chunks[diff_index] - first_input_chunks[diff_index]; + let most_significant_diff = + second_input_chunks[diff_index] - first_input_chunks[diff_index]; v.push(first_input); v.push(second_input); From 0acff53e1a4881639c5b891029955aa84ca9471d Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Wed, 15 Sep 2021 17:47:15 -0700 Subject: [PATCH 25/28] fixes --- src/gates/comparison.rs | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index d8a0735f..6149aa03 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -122,9 +122,8 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); constraints.push(chunks_equal * difference); - let this_diff = second_chunks[i] - first_chunks[i]; most_significant_diff_so_far = chunks_equal * most_significant_diff_so_far - + (F::Extension::ONE - chunks_equal) * this_diff; + + (F::Extension::ONE - chunks_equal) * difference; } let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; @@ -183,7 +182,7 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_product); constraints.push(second_product); - let difference = first_chunks[i] - second_chunks[i]; + let difference = second_chunks[i] - first_chunks[i]; let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; @@ -191,9 +190,8 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(difference * equality_dummy - (F::ONE - chunks_equal)); constraints.push(chunks_equal * difference); - let this_diff = first_chunks[i] - second_chunks[i]; most_significant_diff_so_far = - chunks_equal * most_significant_diff_so_far + (F::ONE - chunks_equal) * this_diff; + chunks_equal * most_significant_diff_so_far + (F::ONE - chunks_equal) * difference; } let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; @@ -266,10 +264,9 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(builder.sub_extension(diff_times_equal, not_equal)); constraints.push(builder.mul_extension(chunks_equal, difference)); - let this_diff = builder.sub_extension(second_chunks[i], first_chunks[i]); let old_diff = builder.mul_extension(chunks_equal, most_significant_diff_so_far); let not_equal = builder.sub_extension(one, chunks_equal); - let new_diff = builder.mul_extension(not_equal, this_diff); + let new_diff = builder.mul_extension(not_equal, difference); most_significant_diff_so_far = builder.add_extension(old_diff, new_diff); } From 7abf48cd07ce3a38462e968a4ffd75247ae6d028 Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Thu, 16 Sep 2021 08:51:44 -0700 Subject: [PATCH 26/28] addressed comments (apart from intermediate wires) --- src/gates/comparison.rs | 118 +++++++++++++++++----------------------- 1 file changed, 50 insertions(+), 68 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 6149aa03..3d7a95a9 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -13,7 +13,7 @@ use crate::plonk::plonk_common::{reduce_with_powers, reduce_with_powers_ext_recu use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase}; use crate::util::ceil_div_usize; -/// A gate for checking that one value is smaller than another. +/// A gate for checking that one value is less than another. #[derive(Clone, Debug)] pub(crate) struct ComparisonGate, const D: usize> { pub(crate) num_bits: usize, @@ -98,19 +98,18 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_chunks_combined - first_input); constraints.push(second_chunks_combined - second_input); - let max_chunk_size = 1 << self.chunk_bits(); + let chunk_size = 1 << self.chunk_bits(); let mut most_significant_diff_so_far = F::Extension::ZERO; - // Find the chosen chunk. for i in 0..self.num_chunks { - let mut first_product = F::Extension::ONE; - let mut second_product = F::Extension::ONE; - for x in 0..max_chunk_size { - let x_F = F::Extension::from_canonical_usize(x); - first_product = first_product * (first_chunks[i] - x_F); - second_product = second_product * (second_chunks[i] - x_F); - } + // Range-check the chunks to be less than `chunk_size`. + let first_product = (0..chunk_size) + .map(|x| first_chunks[i] - F::Extension::from_canonical_usize(x)) + .product(); + let second_product = (0..chunk_size) + .map(|x| second_chunks[i] - F::Extension::from_canonical_usize(x)) + .product(); constraints.push(first_product); constraints.push(second_product); @@ -118,10 +117,11 @@ impl, const D: usize> Gate for ComparisonGate let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; - // Two constraints identifying index. + // Two constraints to assert that `chunks_equal` is valid. constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); constraints.push(chunks_equal * difference); + // Update `most_significant_diff_so_far`. most_significant_diff_so_far = chunks_equal * most_significant_diff_so_far + (F::Extension::ONE - chunks_equal) * difference; } @@ -129,12 +129,10 @@ impl, const D: usize> Gate for ComparisonGate let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; constraints.push(most_significant_diff - most_significant_diff_so_far); - // Range check - let mut product = F::Extension::ONE; - for x in 0..max_chunk_size { - let x_F = F::Extension::from_canonical_usize(x); - product = product * (most_significant_diff - x_F); - } + // Range check `most_significant_diff` to be less than `chunk_size`. + let product = (1..chunk_size) + .map(|x| most_significant_diff - F::Extension::from_canonical_usize(x)) + .product(); constraints.push(product); constraints @@ -166,19 +164,18 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(first_chunks_combined - first_input); constraints.push(second_chunks_combined - second_input); - let max_chunk_size = 1 << self.chunk_bits(); + let chunk_size = 1 << self.chunk_bits(); let mut most_significant_diff_so_far = F::ZERO; - // Find the chosen chunk. for i in 0..self.num_chunks { - let mut first_product = F::ONE; - let mut second_product = F::ONE; - for x in 0..max_chunk_size { - let x_F = F::from_canonical_usize(x); - first_product = first_product * (first_chunks[i] - x_F); - second_product = second_product * (second_chunks[i] - x_F); - } + // Range-check the chunks to be less than `chunk_size`. + let first_product = (0..chunk_size) + .map(|x| first_chunks[i] - F::from_canonical_usize(x)) + .product(); + let second_product = (0..chunk_size) + .map(|x| second_chunks[i] - F::from_canonical_usize(x)) + .product(); constraints.push(first_product); constraints.push(second_product); @@ -186,10 +183,11 @@ impl, const D: usize> Gate for ComparisonGate let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; - // Two constraints identifying index. + // Two constraints to assert that `chunks_equal` is valid. constraints.push(difference * equality_dummy - (F::ONE - chunks_equal)); constraints.push(chunks_equal * difference); + // Update `most_significant_diff_so_far`. most_significant_diff_so_far = chunks_equal * most_significant_diff_so_far + (F::ONE - chunks_equal) * difference; } @@ -197,12 +195,10 @@ impl, const D: usize> Gate for ComparisonGate let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; constraints.push(most_significant_diff - most_significant_diff_so_far); - // Range check - let mut product = F::ONE; - for x in 0..max_chunk_size { - let x_F = F::from_canonical_usize(x); - product = product * (most_significant_diff - x_F); - } + // Range check `most_significant_diff` to be less than `chunk_size`. + let product = (1..chunk_size) + .map(|x| most_significant_diff - F::from_canonical_usize(x)) + .product(); constraints.push(product); constraints @@ -235,16 +231,17 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(builder.sub_extension(first_chunks_combined, first_input)); constraints.push(builder.sub_extension(second_chunks_combined, second_input)); - let max_chunk_size = 1 << self.chunk_bits(); + let chunk_size = 1 << self.chunk_bits(); let mut most_significant_diff_so_far = builder.zero_extension(); let one = builder.one_extension(); // Find the chosen chunk. for i in 0..self.num_chunks { + // Range-check the chunks to be less than `chunk_size`. let mut first_product = one; let mut second_product = one; - for x in 0..max_chunk_size { + for x in 0..chunk_size { let x_F = builder.constant_extension(F::Extension::from_canonical_usize(x)); let first_diff = builder.sub_extension(first_chunks[i], x_F); let second_diff = builder.sub_extension(second_chunks[i], x_F); @@ -258,12 +255,13 @@ impl, const D: usize> Gate for ComparisonGate let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)]; let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)]; - // Two constraints identifying index. + // Two constraints to assert that `chunks_equal` is valid. let diff_times_equal = builder.mul_extension(difference, equality_dummy); let not_equal = builder.sub_extension(one, chunks_equal); constraints.push(builder.sub_extension(diff_times_equal, not_equal)); constraints.push(builder.mul_extension(chunks_equal, difference)); + // Update `most_significant_diff_so_far`. let old_diff = builder.mul_extension(chunks_equal, most_significant_diff_so_far); let not_equal = builder.sub_extension(one, chunks_equal); let new_diff = builder.mul_extension(not_equal, difference); @@ -274,9 +272,9 @@ impl, const D: usize> Gate for ComparisonGate constraints .push(builder.sub_extension(most_significant_diff, most_significant_diff_so_far)); - // Range check + // Range check `most_significant_diff` to be less than `chunk_size`. let mut product = builder.one_extension(); - for x in 0..max_chunk_size { + for x in 1..chunk_size { let x_F = builder.constant_extension(F::Extension::from_canonical_usize(x)); let diff = builder.sub_extension(most_significant_diff, x_F); product = builder.mul_extension(product, diff); @@ -349,30 +347,22 @@ impl, const D: usize> SimpleGenerator debug_assert!(first_input_u64 < second_input_u64); - let first_input_bits: Vec = (0..self.gate.num_bits) + let chunk_size = 1 << self.gate.chunk_bits(); + let first_input_chunks: Vec = (0..self.gate.num_chunks) .scan(first_input_u64, |acc, _| { - let tmp = *acc % 2; - *acc /= 2; + let tmp = *acc % chunk_size; + *acc /= chunk_size; Some(F::from_canonical_u64(tmp)) }) .collect(); - let second_input_bits: Vec = (0..self.gate.num_bits) + let second_input_chunks: Vec = (0..self.gate.num_chunks) .scan(second_input_u64, |acc, _| { - let tmp = *acc % 2; - *acc /= 2; + let tmp = *acc % chunk_size; + *acc /= chunk_size; Some(F::from_canonical_u64(tmp)) }) .collect(); - let first_input_chunks: Vec = first_input_bits - .chunks(self.gate.chunk_bits()) - .map(|bits| reduce_with_powers(&bits, F::TWO)) - .collect(); - let second_input_chunks: Vec = second_input_bits - .chunks(self.gate.chunk_bits()) - .map(|bits| reduce_with_powers(&bits, F::TWO)) - .collect(); - let chunks_equal: Vec = (0..self.gate.num_chunks) .map(|i| F::from_bool(first_input_chunks[i] == second_input_chunks[i])) .collect(); @@ -489,30 +479,22 @@ mod tests { let first_input_u64 = first_input.to_canonical_u64(); let second_input_u64 = second_input.to_canonical_u64(); - let first_input_bits: Vec = (0..num_bits) + let chunk_size = 1 << chunk_bits; + let mut first_input_chunks: Vec = (0..num_chunks) .scan(first_input_u64, |acc, _| { - let tmp = *acc % 2; - *acc /= 2; + let tmp = *acc % chunk_size; + *acc /= chunk_size; Some(F::from_canonical_u64(tmp)) }) .collect(); - let second_input_bits: Vec = (0..num_bits) + let mut second_input_chunks: Vec = (0..num_chunks) .scan(second_input_u64, |acc, _| { - let tmp = *acc % 2; - *acc /= 2; + let tmp = *acc % chunk_size; + *acc /= chunk_size; Some(F::from_canonical_u64(tmp)) }) .collect(); - let mut first_input_chunks: Vec = first_input_bits - .chunks(chunk_bits) - .map(|bits| reduce_with_powers(&bits, F::TWO)) - .collect(); - let mut second_input_chunks: Vec = second_input_bits - .chunks(chunk_bits) - .map(|bits| reduce_with_powers(&bits, F::TWO)) - .collect(); - let mut chunks_equal: Vec = (0..num_chunks) .map(|i| F::from_bool(first_input_chunks[i] == second_input_chunks[i])) .collect(); From 8681cdec541e85a7ca9a4c2d9de7f78d2255c47a Mon Sep 17 00:00:00 2001 From: Nicholas Ward Date: Thu, 16 Sep 2021 11:16:32 -0700 Subject: [PATCH 27/28] intermediate wires --- src/gates/comparison.rs | 59 ++++++++++++++++++++++++++++------------- 1 file changed, 41 insertions(+), 18 deletions(-) diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs index 3d7a95a9..d928bd6f 100644 --- a/src/gates/comparison.rs +++ b/src/gates/comparison.rs @@ -65,6 +65,11 @@ impl, const D: usize> ComparisonGate { debug_assert!(chunk < self.num_chunks); 3 + 3 * self.num_chunks + chunk } + + pub fn wire_intermediate_value(&self, chunk: usize) -> usize { + debug_assert!(chunk < self.num_chunks); + 3 + 4 * self.num_chunks + chunk + } } impl, const D: usize> Gate for ComparisonGate { @@ -122,8 +127,10 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(chunks_equal * difference); // Update `most_significant_diff_so_far`. - most_significant_diff_so_far = chunks_equal * most_significant_diff_so_far - + (F::Extension::ONE - chunks_equal) * difference; + let intermediate_value = vars.local_wires[self.wire_intermediate_value(i)]; + constraints.push(intermediate_value - chunks_equal * most_significant_diff_so_far); + most_significant_diff_so_far = + intermediate_value + (F::Extension::ONE - chunks_equal) * difference; } let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; @@ -188,8 +195,10 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(chunks_equal * difference); // Update `most_significant_diff_so_far`. + let intermediate_value = vars.local_wires[self.wire_intermediate_value(i)]; + constraints.push(intermediate_value - chunks_equal * most_significant_diff_so_far); most_significant_diff_so_far = - chunks_equal * most_significant_diff_so_far + (F::ONE - chunks_equal) * difference; + intermediate_value + (F::ONE - chunks_equal) * difference; } let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; @@ -262,10 +271,13 @@ impl, const D: usize> Gate for ComparisonGate constraints.push(builder.mul_extension(chunks_equal, difference)); // Update `most_significant_diff_so_far`. + let intermediate_value = vars.local_wires[self.wire_intermediate_value(i)]; let old_diff = builder.mul_extension(chunks_equal, most_significant_diff_so_far); + constraints.push(builder.sub_extension(intermediate_value, old_diff)); + let not_equal = builder.sub_extension(one, chunks_equal); let new_diff = builder.mul_extension(not_equal, difference); - most_significant_diff_so_far = builder.add_extension(old_diff, new_diff); + most_significant_diff_so_far = builder.add_extension(intermediate_value, new_diff); } let most_significant_diff = vars.local_wires[self.wire_most_significant_diff()]; @@ -297,7 +309,7 @@ impl, const D: usize> Gate for ComparisonGate } fn num_wires(&self) -> usize { - self.wire_chunks_equal(self.num_chunks - 1) + 1 + self.wire_intermediate_value(self.num_chunks - 1) + 1 } fn num_constants(&self) -> usize { @@ -305,11 +317,11 @@ impl, const D: usize> Gate for ComparisonGate } fn degree(&self) -> usize { - (self.num_chunks + 1).max(1 << self.chunk_bits()) + 1 << self.chunk_bits() } fn num_constraints(&self) -> usize { - 4 + 4 * self.num_chunks + 4 + 5 * self.num_chunks } } @@ -372,15 +384,17 @@ impl, const D: usize> SimpleGenerator .map(|(&f, &s)| if f == s { F::ONE } else { F::ONE / (s - f) }) .collect(); - let mut diff_index = 0; + let mut most_significant_diff_so_far = F::ZERO; + let mut intermediate_values = Vec::new(); for i in 1..self.gate.num_chunks { if first_input_chunks[i] != second_input_chunks[i] { - diff_index = i; + most_significant_diff_so_far = second_input_chunks[i] - first_input_chunks[i]; + intermediate_values.push(F::ZERO); + } else { + intermediate_values.push(most_significant_diff_so_far); } } - - let most_significant_diff = - second_input_chunks[diff_index] - first_input_chunks[diff_index]; + let most_significant_diff = most_significant_diff_so_far; out_buffer.set_wire( local_wire(self.gate.wire_most_significant_diff()), @@ -400,6 +414,10 @@ impl, const D: usize> SimpleGenerator 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_intermediate_value(i)), + intermediate_values[i], + ); } } } @@ -444,6 +462,8 @@ mod tests { assert_eq!(gate.wire_equality_dummy(4), 17); assert_eq!(gate.wire_chunks_equal(0), 18); assert_eq!(gate.wire_chunks_equal(4), 22); + assert_eq!(gate.wire_intermediate_value(0), 23); + assert_eq!(gate.wire_intermediate_value(4), 27); } #[test] @@ -504,15 +524,17 @@ mod tests { .map(|(&f, &s)| if f == s { F::ONE } else { F::ONE / (s - f) }) .collect(); - let mut diff_index = 0; - for i in 1..num_chunks { + let mut most_significant_diff_so_far = F::ZERO; + let mut intermediate_values = Vec::new(); + for i in 0..num_chunks { if first_input_chunks[i] != second_input_chunks[i] { - diff_index = i; + most_significant_diff_so_far = second_input_chunks[i] - first_input_chunks[i]; + intermediate_values.push(F::ZERO); + } else { + intermediate_values.push(most_significant_diff_so_far); } } - - let most_significant_diff = - second_input_chunks[diff_index] - first_input_chunks[diff_index]; + let most_significant_diff = most_significant_diff_so_far; v.push(first_input); v.push(second_input); @@ -521,6 +543,7 @@ mod tests { v.append(&mut second_input_chunks); v.append(&mut equality_dummies); v.append(&mut chunks_equal); + v.append(&mut intermediate_values); v.iter().map(|&x| x.into()).collect::>() }; From d3de2b551875c18ab2569e702d41b779072a41d2 Mon Sep 17 00:00:00 2001 From: Jakub Nabaglo Date: Fri, 17 Sep 2021 10:04:05 -0700 Subject: [PATCH 28/28] Fix alignment assumptions in AVX2 Poseidon --- src/hash/poseidon_avx2.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/hash/poseidon_avx2.rs b/src/hash/poseidon_avx2.rs index cc4a3d1d..c2ab1ac4 100644 --- a/src/hash/poseidon_avx2.rs +++ b/src/hash/poseidon_avx2.rs @@ -214,10 +214,10 @@ pub unsafe fn crandall_poseidon_const_avx2( round_constants: [u64; 4 * PACKED_WIDTH], ) { let packed_state = PackedCrandallAVX2::pack_slice_mut(state); - let packed_round_constants = - std::slice::from_raw_parts((&round_constants).as_ptr().cast::<__m256i>(), PACKED_WIDTH); for i in 0..PACKED_WIDTH { - packed_state[i] = packed_state[i].add_canonical_u64(packed_round_constants[i]); + let constants_ptr = (&round_constants[4 * i..4 * i + 4]).as_ptr(); + let packed_constants = _mm256_loadu_si256(constants_ptr.cast::<__m256i>()); + packed_state[i] = packed_state[i].add_canonical_u64(packed_constants); } }