mirror of
https://github.com/logos-storage/plonky2.git
synced 2026-01-10 01:33:07 +00:00
removed copies
This commit is contained in:
Nicholas Ward
parent
8a726d5a86
commit
26c3edf465
@ -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<F: PrimeField + Extendable<D>, const D: usize> {
|
||||
pub(crate) num_copies: usize,
|
||||
pub(crate) num_bits: usize,
|
||||
pub(crate) num_chunks: usize,
|
||||
_phantom: PhantomData<F>,
|
||||
}
|
||||
|
||||
impl<F: RichField + Extendable<D>, const D: usize> ComparisonGate<F, D> {
|
||||
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<F: RichField + Extendable<D>, const D: usize> ComparisonGate<F, D> {
|
||||
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<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
|
||||
fn eval_unfiltered(&self, vars: EvaluationVars<F, D>) -> Vec<F::Extension> {
|
||||
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<F::Extension> = (0..self.num_chunks)
|
||||
.map(|i| vars.local_wires[self.wire_first_chunk_val(c, i)])
|
||||
.collect();
|
||||
let second_chunks: Vec<F::Extension> = (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<F::Extension> = (0..self.num_chunks)
|
||||
.map(|i| vars.local_wires[self.wire_first_chunk_val(i)])
|
||||
.collect();
|
||||
let second_chunks: Vec<F::Extension> = (0..self.num_chunks)
|
||||
.map(|i| vars.local_wires[self.wire_second_chunk_val(i)])
|
||||
.collect();
|
||||
|
||||
let chunk_base_powers: Vec<F::Extension> = (0..self.num_chunks)
|
||||
.map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits()) as u64))
|
||||
.collect();
|
||||
let chunk_base_powers: Vec<F::Extension> = (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<F::Extension> = (0..self.chunk_bits() + 1)
|
||||
.map(|i| vars.local_wires[self.wire_z_bit(c, i)])
|
||||
.collect();
|
||||
|
||||
let powers_of_two: Vec<F::Extension> = (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<F::Extension> = (0..self.chunk_bits() + 1)
|
||||
.map(|i| vars.local_wires[self.wire_z_bit(i)])
|
||||
.collect();
|
||||
|
||||
let powers_of_two: Vec<F::Extension> = (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<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
|
||||
gate_index: usize,
|
||||
_local_constants: &[F],
|
||||
) -> Vec<Box<dyn WitnessGenerator<F>>> {
|
||||
(0..self.num_copies)
|
||||
.map(|c| {
|
||||
let gen = ComparisonGenerator::<F, D> {
|
||||
gate_index,
|
||||
gate: self.clone(),
|
||||
copy: c,
|
||||
};
|
||||
let g: Box<dyn WitnessGenerator<F>> = Box::new(gen.adapter());
|
||||
g
|
||||
})
|
||||
.collect()
|
||||
let gen = ComparisonGenerator::<F, D> {
|
||||
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<F: RichField + Extendable<D>, const D: usize> Gate<F, D> 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<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
|
||||
struct ComparisonGenerator<F: RichField + Extendable<D>, const D: usize> {
|
||||
gate_index: usize,
|
||||
gate: ComparisonGate<F, D>,
|
||||
copy: usize,
|
||||
}
|
||||
|
||||
impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
|
||||
@ -233,8 +201,8 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
|
||||
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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
|
||||
|
||||
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<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
|
||||
})
|
||||
.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<CrandallField, 4>;
|
||||
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::<CrandallField, _, 4>(ComparisonGate::<_, 4>::new_from_config(
|
||||
CircuitConfig::large_config(),
|
||||
num_bits,
|
||||
num_chunks,
|
||||
))
|
||||
test_low_degree::<CrandallField, _, 4>(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::<CrandallField, _, 4>(ComparisonGate::<_, 4>::new_from_config(
|
||||
CircuitConfig::large_config(),
|
||||
num_bits,
|
||||
num_chunks,
|
||||
))
|
||||
test_eval_fns::<CrandallField, _, 4>(ComparisonGate::<_, 4>::new(num_bits, num_chunks))
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -524,7 +475,6 @@ mod tests {
|
||||
.collect();
|
||||
|
||||
let gate = ComparisonGate::<F, D> {
|
||||
num_copies,
|
||||
num_bits,
|
||||
num_chunks,
|
||||
_phantom: PhantomData,
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user