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

define columns for CTL closer to the constraints (#573)

Browse Source
This commit is contained in:
Jacqueline Nabaglo 2022-06-21 10:28:44 -07:00 committed by GitHub
parent 2e818172f0
commit 3aaab765dd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 72 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
evm/src/all_stark.rs
View File

@ -67,11 +67,12 @@ mod tests {
use crate::all_stark::{AllStark, Table};
use crate::config::StarkConfig;
use crate::cpu::columns::{KECCAK_INPUT_LIMBS, KECCAK_OUTPUT_LIMBS};
use crate::cpu::cpu_stark::CpuStark;
use crate::cross_table_lookup::{Column, CrossTableLookup, TableWithColumns};
use crate::keccak::keccak_stark::{KeccakStark, NUM_INPUTS, NUM_ROUNDS};
use crate::logic;
use crate::logic::LogicStark;
use crate::cpu::cpu_stark::{self as cpu_stark_mod, CpuStark};
use crate::cross_table_lookup::{CrossTableLookup, TableWithColumns};
use crate::keccak::keccak_stark::{
self as keccak_stark_mod, KeccakStark, NUM_INPUTS, NUM_ROUNDS,
};
use crate::logic::{self, LogicStark};
use crate::proof::AllProof;
use crate::prover::prove;
use crate::recursive_verifier::{
@ -228,71 +229,27 @@ mod tests {
&logic_trace,
);
let mut cpu_keccak_input_output = cpu::columns::KECCAK_INPUT_LIMBS.collect::<Vec<_>>();
cpu_keccak_input_output.extend(cpu::columns::KECCAK_OUTPUT_LIMBS);
let mut keccak_keccak_input_output = (0..2 * NUM_INPUTS)
.map(keccak::registers::reg_input_limb)
.collect::<Vec<_>>();
keccak_keccak_input_output.extend(Column::singles(
(0..2 * NUM_INPUTS).map(keccak::registers::reg_output_limb),
));
let cpu_logic_input_output = {
let mut res = vec![
cpu::columns::IS_AND,
cpu::columns::IS_OR,
cpu::columns::IS_XOR,
];
res.extend(cpu::columns::LOGIC_INPUT0);
res.extend(cpu::columns::LOGIC_INPUT1);
res.extend(cpu::columns::LOGIC_OUTPUT);
res
};
let logic_logic_input_output = {
let mut res = vec![
logic::columns::IS_AND,
logic::columns::IS_OR,
logic::columns::IS_XOR,
];
res.extend(logic::columns::INPUT0_PACKED);
res.extend(logic::columns::INPUT1_PACKED);
res.extend(logic::columns::RESULT);
res
};
let cross_table_lookups = vec![
CrossTableLookup::new(
vec![TableWithColumns::new(
Table::Cpu,
Column::singles(cpu_keccak_input_output).collect(),
Some(Column::single(cpu::columns::IS_KECCAK)),
cpu_stark_mod::ctl_data_keccak(),
Some(cpu_stark_mod::ctl_filter_keccak()),
)],
TableWithColumns::new(
Table::Keccak,
keccak_keccak_input_output,
Some(Column::single(keccak::registers::reg_step(NUM_ROUNDS - 1))),
keccak_stark_mod::ctl_data(),
Some(keccak_stark_mod::ctl_filter()),
),
None,
),
CrossTableLookup::new(
vec![TableWithColumns::new(
Table::Cpu,
Column::singles(cpu_logic_input_output).collect(),
Some(Column::sum([
cpu::columns::IS_AND,
cpu::columns::IS_OR,
cpu::columns::IS_XOR,
])),
cpu_stark_mod::ctl_data_logic(),
Some(cpu_stark_mod::ctl_filter_logic()),
)],
TableWithColumns::new(
Table::Logic,
Column::singles(logic_logic_input_output).collect(),
Some(Column::sum([
logic::columns::IS_AND,
logic::columns::IS_OR,
logic::columns::IS_XOR,
])),
),
TableWithColumns::new(Table::Logic, logic::ctl_data(), Some(logic::ctl_filter())),
None,
),
];

28
evm/src/cpu/cpu_stark.rs
View File

@ -1,15 +1,43 @@
use std::marker::PhantomData;
use plonky2::field::extension_field::{Extendable, FieldExtension};
use plonky2::field::field_types::Field;
use plonky2::field::packed_field::PackedField;
use plonky2::hash::hash_types::RichField;
use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::cpu::{columns, decode, simple_logic};
use crate::cross_table_lookup::Column;
use crate::permutation::PermutationPair;
use crate::stark::Stark;
use crate::vars::{StarkEvaluationTargets, StarkEvaluationVars};
pub fn ctl_data_keccak<F: Field>() -> Vec<Column<F>> {
let mut res: Vec<_> = columns::KECCAK_INPUT_LIMBS.map(Column::single).collect();
res.extend(columns::KECCAK_OUTPUT_LIMBS.map(Column::single));
res
}
pub fn ctl_filter_keccak<F: Field>() -> Column<F> {
Column::single(columns::IS_KECCAK)
}
pub fn ctl_data_logic<F: Field>() -> Vec<Column<F>> {
let mut res = vec![
Column::single(columns::IS_AND),
Column::single(columns::IS_OR),
Column::single(columns::IS_XOR),
];
res.extend(columns::LOGIC_INPUT0.map(Column::single));
res.extend(columns::LOGIC_INPUT1.map(Column::single));
res.extend(columns::LOGIC_OUTPUT.map(Column::single));
res
}
pub fn ctl_filter_logic<F: Field>() -> Column<F> {
Column::sum([columns::IS_AND, columns::IS_OR, columns::IS_XOR])
}
#[derive(Copy, Clone)]
pub struct CpuStark<F, const D: usize> {
pub f: PhantomData<F>,

14
evm/src/keccak/keccak_stark.rs
View File

@ -3,6 +3,7 @@ use std::marker::PhantomData;
use itertools::Itertools;
use log::info;
use plonky2::field::extension_field::{Extendable, FieldExtension};
use plonky2::field::field_types::Field;
use plonky2::field::packed_field::PackedField;
use plonky2::field::polynomial::PolynomialValues;
use plonky2::hash::hash_types::RichField;
@ -11,13 +12,14 @@ use plonky2::timed;
use plonky2::util::timing::TimingTree;
use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::cross_table_lookup::Column;
use crate::keccak::constants::{rc_value, rc_value_bit};
use crate::keccak::logic::{
andn, andn_gen, andn_gen_circuit, xor, xor3_gen, xor3_gen_circuit, xor_gen, xor_gen_circuit,
};
use crate::keccak::registers::{
reg_a, reg_a_prime, reg_a_prime_prime, reg_a_prime_prime_0_0_bit, reg_a_prime_prime_prime,
reg_b, reg_c, reg_c_partial, reg_step, NUM_REGISTERS,
reg_b, reg_c, reg_c_partial, reg_input_limb, reg_output_limb, reg_step, NUM_REGISTERS,
};
use crate::keccak::round_flags::{eval_round_flags, eval_round_flags_recursively};
use crate::stark::Stark;
@ -32,6 +34,16 @@ pub(crate) const NUM_INPUTS: usize = 25;
pub(crate) const NUM_PUBLIC_INPUTS: usize = 0;
pub fn ctl_data<F: Field>() -> Vec<Column<F>> {
let mut res: Vec<_> = (0..2 * NUM_INPUTS).map(reg_input_limb).collect();
res.extend(Column::singles((0..2 * NUM_INPUTS).map(reg_output_limb)));
res
}
pub fn ctl_filter<F: Field>() -> Column<F> {
Column::single(reg_step(NUM_ROUNDS - 1))
}
#[derive(Copy, Clone)]
pub struct KeccakStark<F, const D: usize> {
pub(crate) f: PhantomData<F>,

18
evm/src/logic.rs
View File

@ -2,10 +2,12 @@ use std::marker::PhantomData;
use itertools::izip;
use plonky2::field::extension_field::{Extendable, FieldExtension};
use plonky2::field::field_types::Field;
use plonky2::field::packed_field::PackedField;
use plonky2::hash::hash_types::RichField;
use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::cross_table_lookup::Column;
use crate::stark::Stark;
use crate::vars::{StarkEvaluationTargets, StarkEvaluationVars};
@ -42,6 +44,22 @@ pub(crate) mod columns {
pub const NUM_COLUMNS: usize = INPUT1_BITS.end;
}
pub fn ctl_data<F: Field>() -> Vec<Column<F>> {
let mut res = vec![
Column::single(columns::IS_AND),
Column::single(columns::IS_OR),
Column::single(columns::IS_XOR),
];
res.extend(columns::INPUT0_PACKED.map(Column::single));
res.extend(columns::INPUT1_PACKED.map(Column::single));
res.extend(columns::RESULT.map(Column::single));
res
}
pub fn ctl_filter<F: Field>() -> Column<F> {
Column::sum([columns::IS_AND, columns::IS_OR, columns::IS_XOR])
}
#[derive(Copy, Clone)]
pub struct LogicStark<F, const D: usize> {
pub f: PhantomData<F>,