logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-04-11 14:13:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

fixed errors

Browse Source
This commit is contained in:
Nicholas Ward 2021-09-13 14:25:22 -07:00
parent 9fa0500390
commit 93e6bc626d
1 changed files with 26 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
src/gates/comparison.rs
View File

@ -11,7 +11,7 @@ use crate::iop::witness::{PartitionWitness, Witness};
use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::circuit_data::CircuitConfig;
use crate::plonk::vars::{EvaluationTargets, EvaluationVars, EvaluationVarsBase}; 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. /// A gate for checking that one value is smaller than another.
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -31,7 +31,7 @@ impl<F: RichField + Extendable<D>, const D: usize> ComparisonGate<F, D> {
} }
pub fn field_bits() -> usize { pub fn field_bits() -> usize {
log2_ceil(F::ORDER) bits_u64(F::ORDER)
} }
pub fn num_chunks(&self) -> usize { pub fn num_chunks(&self) -> usize {
@ -118,34 +118,34 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
let second_input = vars.local_wires[self.wire_second_input(c)]; let second_input = vars.local_wires[self.wire_second_input(c)];
// Get chunks and assert that they match // Get chunks and assert that they match
let first_chunks: Vec<F> = (0..self.num_chunks()) let first_chunks: Vec<F::Extension> = (0..self.num_chunks())
.map(|i| vars.local_wires[self.wire_first_chunk_val(c, i)]) .map(|i| vars.local_wires[self.wire_first_chunk_val(c, i)])
.collect(); .collect();
let second_chunks: Vec<F> = (0..self.num_chunks()) let second_chunks: Vec<F::Extension> = (0..self.num_chunks())
.map(|i| vars.local_wires[self.wire_second_chunk_val(c, i)]) .map(|i| vars.local_wires[self.wire_second_chunk_val(c, i)])
.collect(); .collect();
let chunk_base_powers = (0..self.chunk_bits) let chunk_base_powers: Vec<F::Extension> = (0..self.chunk_bits)
.map(|i| F::TWO.exp_u64(i * self.chunk_bits as u64)) .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits) as u64))
.collect(); .collect();
let first_chunks_combined = first_chunks let first_chunks_combined = first_chunks
.iter() .iter()
.zip(chunk_base_powers.iter()) .zip(chunk_base_powers.iter())
.map(|(b, x)| b * x) .map(|(b, x)| *b * *x)
.fold(F::ZERO, |a, b| a + b); .fold(F::Extension::ZERO, |a, b| a + b);
let second_chunks_combined = second_chunks let second_chunks_combined = second_chunks
.iter() .iter()
.zip(chunk_base_powers.iter()) .zip(chunk_base_powers.iter())
.map(|(b, x)| b * x) .map(|(b, x)| *b * *x)
.fold(F::ZERO, |a, b| a + b); .fold(F::Extension::ZERO, |a, b| a + b);
constraints.push(first_chunks_combined - first_input); constraints.push(first_chunks_combined - first_input);
constraints.push(second_chunks_combined - second_input); constraints.push(second_chunks_combined - second_input);
// Get bits to assert they match the chosen chunk. // Get bits to assert they match the chosen chunk.
let powers_of_two: Vec<F> = (0..self.chunk_bits) let powers_of_two: Vec<F::Extension> = (0..self.chunk_bits)
.map(|i| F::TWO.exp_u64(i as u64)) .map(|i| F::Extension::TWO.exp_u64(i as u64))
.collect(); .collect();
let mut most_significant_diff = let mut most_significant_diff =
@ -155,7 +155,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
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 difference = first_chunks[i] - second_chunks[i];
let equality_dummy = vars.local_wires[self.wire_equality_dummy(c, 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. // Two constraints identifying index.
constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal)); constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal));
@ -166,25 +166,21 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
+ (F::Extension::ONE - chunks_equal) * this_diff; + (F::Extension::ONE - chunks_equal) * this_diff;
} }
constraints.push(first_bits_combined - most_significant_diff[0]); let z_bits: Vec<F::Extension> = (0..self.chunk_bits + 1)
constraints.push(second_bits_combined - most_significant_diff[1]);
let z_bits: Vec<F> = (0..self.chunk_size + 1)
.map(|i| vars.local_wires[self.wire_z_bit(c, i)]) .map(|i| vars.local_wires[self.wire_z_bit(c, i)])
.collect(); .collect();
let powers_of_two: Vec<F> = (0..self.chunk_bits + 1) let powers_of_two: Vec<F::Extension> = (0..self.chunk_bits + 1)
.map(|i| F::TWO.exp_u64(i as u64)) .map(|i| F::Extension::TWO.exp_u64(i as u64))
.collect(); .collect();
let z_bits_combined = z_bits let z_bits_combined = z_bits
.iter() .iter()
.zip(powers_of_two.iter()) .zip(powers_of_two.iter())
.map(|(b, x)| b * x) .map(|(b, x)| *b * *x)
.fold(F::ZERO, |a, b| a + b); .fold(F::Extension::ZERO, |a, b| a + b);
let two_n = F::TWO.exp_u64(self.chunk_bits); let two_n = F::Extension::TWO.exp_u64(self.chunk_bits as u64);
let (x, y) = most_significant_diff; constraints.push(z_bits_combined - (two_n + most_significant_diff));
constraints.push(z_bits_combined - (two_n + x - y));
constraints.push(z_bits[self.chunk_bits - 1]); constraints.push(z_bits[self.chunk_bits - 1]);
} }
@ -211,18 +207,19 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
) -> Vec<Box<dyn WitnessGenerator<F>>> { ) -> Vec<Box<dyn WitnessGenerator<F>>> {
(0..self.num_copies) (0..self.num_copies)
.map(|c| { .map(|c| {
let g: Box<dyn WitnessGenerator<F>> = Box::new(ComparisonGenerator::<F, D> { let gen = ComparisonGenerator::<F, D> {
gate_index, gate_index,
gate: self.clone(), gate: self.clone(),
copy: c, copy: c,
}); };
let g: Box<dyn WitnessGenerator<F>> = Box::new(gen.adapter());
g g
}) })
.collect() .collect()
} }
fn num_wires(&self) -> usize { 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 { fn num_constants(&self) -> usize {
@ -268,7 +265,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
let first_input = get_local_wire(self.gate.wire_first_input(self.copy)); 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 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 first_input_u64 = first_input.to_canonical_u64();
let second_input_u64 = second_input.to_canonical_u64(); let second_input_u64 = second_input.to_canonical_u64();
@ -329,7 +326,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
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(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(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() { for i in 0..self.gate.num_chunks() {
out_buffer.set_wire( out_buffer.set_wire(