logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-03 22:33:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Missed some

Browse Source
This commit is contained in:
wborgeaud 2022-05-17 11:15:53 +02:00
parent b606d99e07
commit 7676f907bf
7 changed files with 40 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
starky/src/recursive_verifier.rs
View File

@ -233,12 +233,12 @@ pub fn add_virtual_stark_proof<F: RichField + Extendable<D>, S: Stark<F, D>, con
trace_cap: builder.add_virtual_cap(cap_height),
permutation_zs_cap,
quotient_polys_cap: builder.add_virtual_cap(cap_height),
openings: add_stark_opening_set::<F, S, D>(builder, stark, config),
openings: add_stark_opening_set_target::<F, S, D>(builder, stark, config),
opening_proof: builder.add_virtual_fri_proof(&num_leaves_per_oracle, &fri_params),
}
}
fn add_stark_opening_set<F: RichField + Extendable<D>, S: Stark<F, D>, const D: usize>(
fn add_stark_opening_set_target<F: RichField + Extendable<D>, S: Stark<F, D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
stark: S,
config: &StarkConfig,

2
system_zero/src/alu/addition.rs
View File

@ -44,7 +44,7 @@ pub(crate) fn eval_addition<F: Field, P: PackedField<Scalar = F>>(
yield_constr.constraint(is_add * (out - computed_out));
}
pub(crate) fn eval_addition_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_addition_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
local_values: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,

14
system_zero/src/alu/bitops.rs
View File

@ -130,7 +130,7 @@ pub(crate) fn eval_bitop<F: Field, P: PackedField<Scalar = F>>(
);
}
pub(crate) fn constrain_all_to_bits<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn constrain_all_to_bits_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
filter: ExtensionTarget<D>,
@ -144,7 +144,7 @@ pub(crate) fn constrain_all_to_bits<F: RichField + Extendable<D>, const D: usize
}
/// As for `eval_bitop`, but build with `builder`.
fn eval_bitop_32_recursively<F: RichField + Extendable<D>, const D: usize>(
fn eval_bitop_32_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
input_a_regs: [usize; 32],
@ -164,8 +164,8 @@ fn eval_bitop_32_recursively<F: RichField + Extendable<D>, const D: usize>(
// Ensure that the inputs are bits
let inst_constr = builder.add_many_extension(&[is_and, is_ior, is_xor, is_andnot]);
constrain_all_to_bits(builder, yield_constr, inst_constr, &a_bits);
constrain_all_to_bits(builder, yield_constr, inst_constr, &b_bits);
constrain_all_to_bits_circuit(builder, yield_constr, inst_constr, &a_bits);
constrain_all_to_bits_circuit(builder, yield_constr, inst_constr, &b_bits);
// Output
let output = lv[output_reg];
@ -209,13 +209,13 @@ fn eval_bitop_32_recursively<F: RichField + Extendable<D>, const D: usize>(
}
/// As for `eval_bitop` but with a builder.
pub(crate) fn eval_bitop_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_bitop_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
) {
// Recursive constraint for lo half
eval_bitop_32_recursively(
eval_bitop_32_circuit(
builder,
lv,
COL_BIT_DECOMP_INPUT_A_LO_BIN_REGS,
@ -224,7 +224,7 @@ pub(crate) fn eval_bitop_recursively<F: RichField + Extendable<D>, const D: usiz
yield_constr,
);
// Recursive constraint for hi half
eval_bitop_32_recursively(
eval_bitop_32_circuit(
builder,
lv,
COL_BIT_DECOMP_INPUT_A_HI_BIN_REGS,

22
system_zero/src/alu/mod.rs
View File

@ -7,14 +7,14 @@ use starky::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsume
use starky::vars::StarkEvaluationTargets;
use starky::vars::StarkEvaluationVars;
use crate::alu::addition::{eval_addition, eval_addition_recursively, generate_addition};
use crate::alu::bitops::{eval_bitop, eval_bitop_recursively, generate_bitop};
use crate::alu::addition::{eval_addition, eval_addition_circuit, generate_addition};
use crate::alu::bitops::{eval_bitop, eval_bitop_circuit, generate_bitop};
use crate::alu::division::{eval_division, eval_division_circuit, generate_division};
use crate::alu::mul_add::{eval_mul_add, eval_mul_add_circuit, generate_mul_add};
use crate::alu::rotate_shift::{
eval_rotate_left, eval_rotate_left_recursively, eval_rotate_right,
eval_rotate_right_recursively, eval_shift_left, eval_shift_left_recursively, eval_shift_right,
eval_shift_right_recursively, generate_rotate_shift,
eval_rotate_left, eval_rotate_left_circuit, eval_rotate_right, eval_rotate_right_circuit,
eval_shift_left, eval_shift_left_circuit, eval_shift_right, eval_shift_right_circuit,
generate_rotate_shift,
};
use crate::alu::subtraction::{eval_subtraction, eval_subtraction_circuit, generate_subtraction};
use crate::public_input_layout::NUM_PUBLIC_INPUTS;
@ -96,13 +96,13 @@ pub(crate) fn eval_alu_circuit<F: RichField + Extendable<D>, const D: usize>(
yield_constr.constraint(builder, constraint);
}
eval_addition_recursively(builder, local_values, yield_constr);
eval_addition_circuit(builder, local_values, yield_constr);
eval_subtraction_circuit(builder, local_values, yield_constr);
eval_mul_add_circuit(builder, local_values, yield_constr);
eval_division_circuit(builder, local_values, yield_constr);
eval_bitop_recursively(builder, local_values, yield_constr);
eval_rotate_left_recursively(builder, local_values, yield_constr);
eval_rotate_right_recursively(builder, local_values, yield_constr);
eval_shift_left_recursively(builder, local_values, yield_constr);
eval_shift_right_recursively(builder, local_values, yield_constr);
eval_bitop_circuit(builder, local_values, yield_constr);
eval_rotate_left_circuit(builder, local_values, yield_constr);
eval_rotate_right_circuit(builder, local_values, yield_constr);
eval_shift_left_circuit(builder, local_values, yield_constr);
eval_shift_right_circuit(builder, local_values, yield_constr);
}

32
system_zero/src/alu/rotate_shift.rs
View File

@ -6,7 +6,7 @@ use plonky2::iop::ext_target::ExtensionTarget;
use plonky2::plonk::circuit_builder::CircuitBuilder;
use starky::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::alu::bitops::constrain_all_to_bits;
use crate::alu::bitops::constrain_all_to_bits_circuit;
use crate::registers::alu::*;
use crate::registers::NUM_COLUMNS;
@ -343,7 +343,7 @@ pub(crate) fn eval_shift_right<F: Field, P: PackedField<Scalar = F>>(
yield_constr.constraint(is_shl * hi_constr);
}
fn constrain_pow_exp_recursively<F: RichField + Extendable<D>, const D: usize>(
fn constrain_pow_exp_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
@ -358,8 +358,8 @@ fn constrain_pow_exp_recursively<F: RichField + Extendable<D>, const D: usize>(
let pow_exp = lv[COL_ROTATE_SHIFT_POW_EXP];
// Check that every "bit" of exp_bits and exp_ge32_bit is 0 or 1
constrain_all_to_bits(builder, yield_constr, filter, &exp_bits);
constrain_all_to_bits(builder, yield_constr, filter, &[exp_ge32_bit]);
constrain_all_to_bits_circuit(builder, yield_constr, filter, &exp_bits);
constrain_all_to_bits_circuit(builder, yield_constr, filter, &[exp_ge32_bit]);
let one = builder.one_extension();
// c[i-1] = 2^(2^i) - 1
@ -392,7 +392,7 @@ fn constrain_pow_exp_recursively<F: RichField + Extendable<D>, const D: usize>(
yield_constr.constraint(builder, constr4);
}
fn constrain_shifted_are_valid_recursively<F: RichField + Extendable<D>, const D: usize>(
fn constrain_shifted_are_valid_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
@ -438,7 +438,7 @@ fn constrain_shifted_are_valid_recursively<F: RichField + Extendable<D>, const D
yield_constr.constraint(builder, hi_shifted_is_valid);
}
fn eval_rotate_shift_recursively<F: RichField + Extendable<D>, const D: usize>(
fn eval_rotate_shift_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
@ -468,8 +468,8 @@ fn eval_rotate_shift_recursively<F: RichField + Extendable<D>, const D: usize>(
let output_lo = lv[COL_ROTATE_SHIFT_OUTPUT_0];
let output_hi = lv[COL_ROTATE_SHIFT_OUTPUT_1];
constrain_pow_exp_recursively(builder, lv, yield_constr, filter);
constrain_shifted_are_valid_recursively(builder, lv, yield_constr, filter);
constrain_pow_exp_circuit(builder, lv, yield_constr, filter);
constrain_shifted_are_valid_circuit(builder, lv, yield_constr, filter);
let base = builder.constant_extension(F::Extension::from_canonical_u64(1u64 << 32));
let lo_shifted = builder.mul_add_extension(lo_shifted_1, base, lo_shifted_0);
@ -500,7 +500,7 @@ fn eval_rotate_shift_recursively<F: RichField + Extendable<D>, const D: usize>(
)
}
pub(crate) fn eval_rotate_left_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_rotate_left_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
@ -508,7 +508,7 @@ pub(crate) fn eval_rotate_left_recursively<F: RichField + Extendable<D>, const D
let is_rol = lv[IS_ROTATE_LEFT];
let (delta_ge32, lo_shifted_0, lo_shifted_1, hi_shifted_0, hi_shifted_1, output_lo, output_hi) =
eval_rotate_shift_recursively(builder, lv, yield_constr, is_rol);
eval_rotate_shift_circuit(builder, lv, yield_constr, is_rol);
let one = builder.one_extension();
let s0 = builder.add_extension(hi_shifted_1, lo_shifted_0);
@ -537,7 +537,7 @@ pub(crate) fn eval_rotate_left_recursively<F: RichField + Extendable<D>, const D
yield_constr.constraint(builder, hi_constr);
}
pub(crate) fn eval_rotate_right_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_rotate_right_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
@ -545,7 +545,7 @@ pub(crate) fn eval_rotate_right_recursively<F: RichField + Extendable<D>, const
let is_ror = lv[IS_ROTATE_RIGHT];
let (delta_ge32, lo_shifted_0, lo_shifted_1, hi_shifted_0, hi_shifted_1, output_lo, output_hi) =
eval_rotate_shift_recursively(builder, lv, yield_constr, is_ror);
eval_rotate_shift_circuit(builder, lv, yield_constr, is_ror);
let one = builder.one_extension();
let s0 = builder.add_extension(hi_shifted_1, lo_shifted_0);
@ -574,7 +574,7 @@ pub(crate) fn eval_rotate_right_recursively<F: RichField + Extendable<D>, const
yield_constr.constraint(builder, hi_constr);
}
pub(crate) fn eval_shift_left_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_shift_left_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
@ -582,7 +582,7 @@ pub(crate) fn eval_shift_left_recursively<F: RichField + Extendable<D>, const D:
let is_shl = lv[IS_SHIFT_LEFT];
let (delta_ge32, lo_shifted_0, lo_shifted_1, hi_shifted_0, _hi_shifted_1, output_lo, output_hi) =
eval_rotate_shift_recursively(builder, lv, yield_constr, is_shl);
eval_rotate_shift_circuit(builder, lv, yield_constr, is_shl);
let one = builder.one_extension();
let c = builder.sub_extension(one, delta_ge32);
@ -609,7 +609,7 @@ pub(crate) fn eval_shift_left_recursively<F: RichField + Extendable<D>, const D:
yield_constr.constraint(builder, hi_constr);
}
pub(crate) fn eval_shift_right_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_shift_right_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
lv: &[ExtensionTarget<D>; NUM_COLUMNS],
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
@ -617,7 +617,7 @@ pub(crate) fn eval_shift_right_recursively<F: RichField + Extendable<D>, const D
let is_shr = lv[IS_SHIFT_RIGHT];
let (delta_ge32, _lo_shifted_0, lo_shifted_1, hi_shifted_0, hi_shifted_1, output_lo, output_hi) =
eval_rotate_shift_recursively(builder, lv, yield_constr, is_shr);
eval_rotate_shift_circuit(builder, lv, yield_constr, is_shr);
let one = builder.one_extension();
let c = builder.sub_extension(one, delta_ge32);

2
system_zero/src/permutation_unit.rs
View File

@ -172,7 +172,7 @@ pub(crate) fn eval_permutation_unit<F, FE, P, const D: usize>(
}
}
pub(crate) fn eval_permutation_unit_recursively<F: RichField + Extendable<D>, const D: usize>(
pub(crate) fn eval_permutation_unit_circuit<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
vars: StarkEvaluationTargets<D, NUM_COLUMNS, NUM_PUBLIC_INPUTS>,
yield_constr: &mut RecursiveConstraintConsumer<F, D>,

4
system_zero/src/system_zero.rs
View File

@ -22,7 +22,7 @@ use crate::core_registers::{
use crate::lookup::{eval_lookups, eval_lookups_circuit, generate_lookups};
use crate::memory::TransactionMemory;
use crate::permutation_unit::{
eval_permutation_unit, eval_permutation_unit_recursively, generate_permutation_unit,
eval_permutation_unit, eval_permutation_unit_circuit, generate_permutation_unit,
};
use crate::public_input_layout::NUM_PUBLIC_INPUTS;
use crate::registers::{lookup, NUM_COLUMNS};
@ -143,7 +143,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for SystemZero<F,
) {
eval_core_registers_circuit(builder, vars, yield_constr);
eval_alu_circuit(builder, vars, yield_constr);
eval_permutation_unit_recursively(builder, vars, yield_constr);
eval_permutation_unit_circuit(builder, vars, yield_constr);
eval_lookups_circuit(builder, vars, yield_constr);
// TODO: Other units
}