diff --git a/stwo_cairo_prover/crates/cairo-air/src/blake/air.rs b/stwo_cairo_prover/crates/cairo-air/src/blake/air.rs index 4143ac1a50..df284421f5 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/blake/air.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/blake/air.rs @@ -8,8 +8,8 @@ use stwo::prover::ComponentProver; use stwo_cairo_serialize::{CairoDeserialize, CairoSerialize}; use stwo_constraint_framework::TraceLocationAllocator; -use crate::cairo_interaction_elements::CairoInteractionElements; use crate::cairo_claim::{accumulate_relation_uses, RelationUsesDict}; +use crate::cairo_interaction_elements::CairoInteractionElements; use crate::components::{ blake_g, blake_round, blake_round_sigma, triple_xor_32, verify_bitwise_xor_12, }; diff --git a/stwo_cairo_prover/crates/cairo-air/src/builtins_air.rs b/stwo_cairo_prover/crates/cairo-air/src/builtins_air.rs index 7e65bdc8bf..ef13b2aeb6 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/builtins_air.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/builtins_air.rs @@ -9,8 +9,8 @@ use stwo::prover::ComponentProver; use stwo_cairo_serialize::{CairoDeserialize, CairoSerialize}; use stwo_constraint_framework::TraceLocationAllocator; -use crate::cairo_interaction_elements::CairoInteractionElements; use crate::cairo_claim::{accumulate_relation_uses, RelationUsesDict}; +use crate::cairo_interaction_elements::CairoInteractionElements; use crate::components::{ add_mod_builtin, bitwise_builtin, indented_component_display, mul_mod_builtin, pedersen_builtin, poseidon_builtin, range_check_builtin_bits_128, range_check_builtin_bits_96, diff --git a/stwo_cairo_prover/crates/cairo-air/src/cairo_claim.rs b/stwo_cairo_prover/crates/cairo-air/src/cairo_claim.rs index 173e19c6e0..6507c4a4c4 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/cairo_claim.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/cairo_claim.rs @@ -1,26 +1,52 @@ +use std::collections::HashMap; + +use itertools::chain; +use serde::{Deserialize, Serialize}; use stwo::core::channel::Channel; use stwo::core::pcs::TreeVec; use stwo_cairo_serialize::{CairoDeserialize, CairoSerialize}; -use serde::{Deserialize, Serialize}; use crate::blake::air::BlakeContextClaim; use crate::builtins_air::BuiltinsClaim; -use std::collections::HashMap; -use crate::verifier::RelationUse; -use crate::public_data::PublicData; use crate::components::{ - memory_address_to_id, memory_id_to_big, verify_bitwise_xor_4, verify_bitwise_xor_7, - verify_bitwise_xor_8, verify_bitwise_xor_8_b, verify_bitwise_xor_9, verify_instruction, + add_ap_opcode, add_opcode, add_opcode_small, assert_eq_opcode, assert_eq_opcode_double_deref, + assert_eq_opcode_imm, blake_compress_opcode, call_opcode_abs, call_opcode_rel_imm, + generic_opcode, jnz_opcode_non_taken, jnz_opcode_taken, jump_opcode_abs, + jump_opcode_double_deref, jump_opcode_rel, jump_opcode_rel_imm, memory_address_to_id, + memory_id_to_big, mul_opcode, mul_opcode_small, qm_31_add_mul_opcode, ret_opcode, + verify_bitwise_xor_4, verify_bitwise_xor_7, verify_bitwise_xor_8, verify_bitwise_xor_8_b, + verify_bitwise_xor_9, verify_instruction, }; -use crate::opcodes_air::OpcodeClaim; use crate::pedersen::air::PedersenContextClaim; use crate::poseidon::air::PoseidonContextClaim; +use crate::public_data::PublicData; use crate::range_checks_air::RangeChecksClaim; +use crate::verifier::RelationUse; #[derive(Serialize, Deserialize, CairoSerialize, CairoDeserialize)] pub struct CairoClaim { pub public_data: PublicData, - pub opcodes: OpcodeClaim, + // Opcode claim fields (inlined) + pub add: Vec, + pub add_small: Vec, + pub add_ap: Vec, + pub assert_eq: Vec, + pub assert_eq_imm: Vec, + pub assert_eq_double_deref: Vec, + pub blake: Vec, + pub call: Vec, + pub call_rel_imm: Vec, + pub generic: Vec, + pub jnz: Vec, + pub jnz_taken: Vec, + pub jump: Vec, + pub jump_double_deref: Vec, + pub jump_rel: Vec, + pub jump_rel_imm: Vec, + pub mul: Vec, + pub mul_small: Vec, + pub qm31: Vec, + pub ret: Vec, pub verify_instruction: verify_instruction::Claim, pub blake_context: BlakeContextClaim, pub builtins: BuiltinsClaim, @@ -41,7 +67,26 @@ impl CairoClaim { pub fn mix_into(&self, channel: &mut impl Channel) { let Self { public_data, - opcodes, + add, + add_small, + add_ap, + assert_eq, + assert_eq_imm, + assert_eq_double_deref, + blake, + call, + call_rel_imm, + generic, + jnz, + jnz_taken, + jump, + jump_double_deref, + jump_rel, + jump_rel_imm, + mul, + mul_small, + qm31, + ret, verify_instruction, blake_context, builtins, @@ -57,7 +102,33 @@ impl CairoClaim { verify_bitwise_xor_9, } = self; public_data.mix_into(channel); - opcodes.mix_into(channel); + // Mix opcode vectors: first length then each claim + macro_rules! mix_component_vector { + ($field:ident) => { + channel.mix_u64($field.len() as u64); + $field.iter().for_each(|c| c.mix_into(channel)); + }; + } + mix_component_vector!(add); + mix_component_vector!(add_small); + mix_component_vector!(add_ap); + mix_component_vector!(assert_eq); + mix_component_vector!(assert_eq_imm); + mix_component_vector!(assert_eq_double_deref); + mix_component_vector!(blake); + mix_component_vector!(call); + mix_component_vector!(call_rel_imm); + mix_component_vector!(generic); + mix_component_vector!(jnz); + mix_component_vector!(jnz_taken); + mix_component_vector!(jump); + mix_component_vector!(jump_double_deref); + mix_component_vector!(jump_rel); + mix_component_vector!(jump_rel_imm); + mix_component_vector!(mul); + mix_component_vector!(mul_small); + mix_component_vector!(qm31); + mix_component_vector!(ret); verify_instruction.mix_into(channel); blake_context.mix_into(channel); builtins.mix_into(channel); @@ -77,7 +148,28 @@ impl CairoClaim { /// Does not include the preprocessed trace log sizes. pub fn log_sizes(&self) -> TreeVec> { let log_sizes_list = vec![ - self.opcodes.log_sizes(), + TreeVec::concat_cols(chain!( + self.add.iter().map(|c| c.log_sizes()), + self.add_small.iter().map(|c| c.log_sizes()), + self.add_ap.iter().map(|c| c.log_sizes()), + self.assert_eq.iter().map(|c| c.log_sizes()), + self.assert_eq_imm.iter().map(|c| c.log_sizes()), + self.assert_eq_double_deref.iter().map(|c| c.log_sizes()), + self.blake.iter().map(|c| c.log_sizes()), + self.call.iter().map(|c| c.log_sizes()), + self.call_rel_imm.iter().map(|c| c.log_sizes()), + self.generic.iter().map(|c| c.log_sizes()), + self.jnz.iter().map(|c| c.log_sizes()), + self.jnz_taken.iter().map(|c| c.log_sizes()), + self.jump.iter().map(|c| c.log_sizes()), + self.jump_double_deref.iter().map(|c| c.log_sizes()), + self.jump_rel.iter().map(|c| c.log_sizes()), + self.jump_rel_imm.iter().map(|c| c.log_sizes()), + self.mul.iter().map(|c| c.log_sizes()), + self.mul_small.iter().map(|c| c.log_sizes()), + self.qm31.iter().map(|c| c.log_sizes()), + self.ret.iter().map(|c| c.log_sizes()), + )), self.verify_instruction.log_sizes(), self.blake_context.log_sizes(), self.builtins.log_sizes(), @@ -99,7 +191,26 @@ impl CairoClaim { pub fn accumulate_relation_uses(&self, relation_uses: &mut RelationUsesDict) { let Self { public_data: _, - opcodes, + add, + add_small, + add_ap, + assert_eq, + assert_eq_imm, + assert_eq_double_deref, + blake, + call, + call_rel_imm, + generic, + jnz, + jnz_taken, + jump, + jump_double_deref, + jump_rel, + jump_rel_imm, + mul, + mul_small, + qm31, + ret, verify_instruction, blake_context, builtins, @@ -119,7 +230,37 @@ impl CairoClaim { // - verify_bitwise_xor_* // - memory_address_to_id - opcodes.accumulate_relation_uses(relation_uses); + macro_rules! relation_uses_vec { + ($field:ident, $module:ident) => { + $field.iter().for_each(|c| { + accumulate_relation_uses( + relation_uses, + $module::RELATION_USES_PER_ROW, + c.log_size, + ) + }); + }; + } + relation_uses_vec!(add, add_opcode); + relation_uses_vec!(add_small, add_opcode_small); + relation_uses_vec!(add_ap, add_ap_opcode); + relation_uses_vec!(assert_eq, assert_eq_opcode); + relation_uses_vec!(assert_eq_imm, assert_eq_opcode_imm); + relation_uses_vec!(assert_eq_double_deref, assert_eq_opcode_double_deref); + relation_uses_vec!(blake, blake_compress_opcode); + relation_uses_vec!(call, call_opcode_abs); + relation_uses_vec!(call_rel_imm, call_opcode_rel_imm); + relation_uses_vec!(generic, generic_opcode); + relation_uses_vec!(jnz, jnz_opcode_non_taken); + relation_uses_vec!(jnz_taken, jnz_opcode_taken); + relation_uses_vec!(jump, jump_opcode_abs); + relation_uses_vec!(jump_double_deref, jump_opcode_double_deref); + relation_uses_vec!(jump_rel, jump_opcode_rel); + relation_uses_vec!(jump_rel_imm, jump_opcode_rel_imm); + relation_uses_vec!(mul, mul_opcode); + relation_uses_vec!(mul_small, mul_opcode_small); + relation_uses_vec!(qm31, qm_31_add_mul_opcode); + relation_uses_vec!(ret, ret_opcode); builtins.accumulate_relation_uses(relation_uses); blake_context.accumulate_relation_uses(relation_uses); pedersen_context.accumulate_relation_uses(relation_uses); @@ -163,10 +304,10 @@ pub fn accumulate_relation_uses( } } - #[cfg(test)] mod tests { use std::collections::HashMap; + use super::accumulate_relation_uses; use crate::verifier::RelationUse; @@ -191,4 +332,4 @@ mod tests { assert_eq!(relation_uses.get("relation_1"), Some(&12)); assert_eq!(relation_uses.get("relation_2"), Some(&26)); } -} \ No newline at end of file +} diff --git a/stwo_cairo_prover/crates/cairo-air/src/cairo_components.rs b/stwo_cairo_prover/crates/cairo-air/src/cairo_components.rs index e6db99d193..b2fe9857db 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/cairo_components.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/cairo_components.rs @@ -5,22 +5,46 @@ use stwo::prover::ComponentProver; use stwo_constraint_framework::preprocessed_columns::PreProcessedColumnId; use stwo_constraint_framework::TraceLocationAllocator; +use crate::blake::air::BlakeContextComponents; +use crate::builtins_air::BuiltinComponents; use crate::cairo_claim::CairoClaim; use crate::cairo_interaction_claim::CairoInteractionClaim; use crate::cairo_interaction_elements::CairoInteractionElements; use crate::components::{ - indented_component_display, memory_address_to_id, memory_id_to_big, verify_bitwise_xor_4, - verify_bitwise_xor_7, verify_bitwise_xor_8, verify_bitwise_xor_8_b, verify_bitwise_xor_9, - verify_instruction, + add_ap_opcode, add_opcode, add_opcode_small, assert_eq_opcode, assert_eq_opcode_double_deref, + assert_eq_opcode_imm, blake_compress_opcode, call_opcode_abs, call_opcode_rel_imm, + display_components, generic_opcode, indented_component_display, jnz_opcode_non_taken, + jnz_opcode_taken, jump_opcode_abs, jump_opcode_double_deref, jump_opcode_rel, + jump_opcode_rel_imm, memory_address_to_id, memory_id_to_big, mul_opcode, mul_opcode_small, + qm_31_add_mul_opcode, ret_opcode, verify_bitwise_xor_4, verify_bitwise_xor_7, + verify_bitwise_xor_8, verify_bitwise_xor_8_b, verify_bitwise_xor_9, verify_instruction, }; -use crate::opcodes_air::OpcodeComponents; -use crate::builtins_air::BuiltinComponents; -use crate::range_checks_air::RangeChecksComponents; -use crate::blake::air::BlakeContextComponents; use crate::pedersen::air::PedersenContextComponents; use crate::poseidon::air::PoseidonContextComponents; +use crate::range_checks_air::RangeChecksComponents; pub struct CairoComponents { - pub opcodes: OpcodeComponents, + // Opcode components (inlined). + pub add: Vec, + pub add_small: Vec, + pub add_ap: Vec, + pub assert_eq: Vec, + pub assert_eq_imm: Vec, + pub assert_eq_double_deref: Vec, + pub blake: Vec, + pub call: Vec, + pub call_rel_imm: Vec, + pub generic: Vec, + pub jnz: Vec, + pub jnz_taken: Vec, + pub jump: Vec, + pub jump_double_deref: Vec, + pub jump_rel: Vec, + pub jump_rel_imm: Vec, + pub mul: Vec, + pub mul_small: Vec, + pub qm31: Vec, + pub ret: Vec, + // Internal components. pub verify_instruction: verify_instruction::Component, pub blake_context: BlakeContextComponents, pub builtins: BuiltinComponents, @@ -50,12 +74,610 @@ impl CairoComponents { let tree_span_provider = &mut TraceLocationAllocator::new_with_preprocessed_columns(preprocessed_column_ids); - let opcode_components = OpcodeComponents::new( - tree_span_provider, - &cairo_claim.opcodes, - interaction_elements, - &interaction_claim.opcodes, - ); + // Build opcode components (inlined former OpcodeComponents::new) + let add = cairo_claim + .add + .iter() + .zip(interaction_claim.add.iter()) + .map(|(&claim, &interaction_claim)| { + add_opcode::Component::new( + tree_span_provider, + add_opcode::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let add_small = cairo_claim + .add_small + .iter() + .zip(interaction_claim.add_small.iter()) + .map(|(&claim, &interaction_claim)| { + add_opcode_small::Component::new( + tree_span_provider, + add_opcode_small::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let add_ap = cairo_claim + .add_ap + .iter() + .zip(interaction_claim.add_ap.iter()) + .map(|(&claim, &interaction_claim)| { + add_ap_opcode::Component::new( + tree_span_provider, + add_ap_opcode::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + range_check_18_lookup_elements: interaction_elements + .range_checks + .rc_18 + .clone(), + range_check_11_lookup_elements: interaction_elements + .range_checks + .rc_11 + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let assert_eq = cairo_claim + .assert_eq + .iter() + .zip(interaction_claim.assert_eq.iter()) + .map(|(&claim, &interaction_claim)| { + assert_eq_opcode::Component::new( + tree_span_provider, + assert_eq_opcode::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let assert_eq_imm = cairo_claim + .assert_eq_imm + .iter() + .zip(interaction_claim.assert_eq_imm.iter()) + .map(|(&claim, &interaction_claim)| { + assert_eq_opcode_imm::Component::new( + tree_span_provider, + assert_eq_opcode_imm::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let assert_eq_double_deref = cairo_claim + .assert_eq_double_deref + .iter() + .zip(interaction_claim.assert_eq_double_deref.iter()) + .map(|(&claim, &interaction_claim)| { + assert_eq_opcode_double_deref::Component::new( + tree_span_provider, + assert_eq_opcode_double_deref::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let blake = cairo_claim + .blake + .iter() + .zip(interaction_claim.blake.iter()) + .map(|(&claim, &interaction_claim)| { + blake_compress_opcode::Component::new( + tree_span_provider, + blake_compress_opcode::Eval { + claim, + blake_round_lookup_elements: interaction_elements.blake_round.clone(), + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + range_check_7_2_5_lookup_elements: interaction_elements + .range_checks + .rc_7_2_5 + .clone(), + triple_xor_32_lookup_elements: interaction_elements.triple_xor_32.clone(), + verify_bitwise_xor_8_lookup_elements: interaction_elements + .verify_bitwise_xor_8 + .clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let call = cairo_claim + .call + .iter() + .zip(interaction_claim.call.iter()) + .map(|(&claim, &interaction_claim)| { + call_opcode_abs::Component::new( + tree_span_provider, + call_opcode_abs::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let call_rel_imm = cairo_claim + .call_rel_imm + .iter() + .zip(interaction_claim.call_rel_imm.iter()) + .map(|(&claim, &interaction_claim)| { + call_opcode_rel_imm::Component::new( + tree_span_provider, + call_opcode_rel_imm::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let generic = cairo_claim + .generic + .iter() + .zip(interaction_claim.generic.iter()) + .map(|(&claim, &interaction_claim)| { + generic_opcode::Component::new( + tree_span_provider, + generic_opcode::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + range_check_20_lookup_elements: interaction_elements + .range_checks + .rc_20 + .clone(), + range_check_20_b_lookup_elements: interaction_elements + .range_checks + .rc_20_b + .clone(), + range_check_20_c_lookup_elements: interaction_elements + .range_checks + .rc_20_c + .clone(), + range_check_20_d_lookup_elements: interaction_elements + .range_checks + .rc_20_d + .clone(), + range_check_20_e_lookup_elements: interaction_elements + .range_checks + .rc_20_e + .clone(), + range_check_20_f_lookup_elements: interaction_elements + .range_checks + .rc_20_f + .clone(), + range_check_20_g_lookup_elements: interaction_elements + .range_checks + .rc_20_g + .clone(), + range_check_20_h_lookup_elements: interaction_elements + .range_checks + .rc_20_h + .clone(), + range_check_9_9_lookup_elements: interaction_elements + .range_checks + .rc_9_9 + .clone(), + range_check_9_9_b_lookup_elements: interaction_elements + .range_checks + .rc_9_9_b + .clone(), + range_check_9_9_c_lookup_elements: interaction_elements + .range_checks + .rc_9_9_c + .clone(), + range_check_9_9_d_lookup_elements: interaction_elements + .range_checks + .rc_9_9_d + .clone(), + range_check_9_9_e_lookup_elements: interaction_elements + .range_checks + .rc_9_9_e + .clone(), + range_check_9_9_f_lookup_elements: interaction_elements + .range_checks + .rc_9_9_f + .clone(), + range_check_9_9_g_lookup_elements: interaction_elements + .range_checks + .rc_9_9_g + .clone(), + range_check_9_9_h_lookup_elements: interaction_elements + .range_checks + .rc_9_9_h + .clone(), + range_check_18_lookup_elements: interaction_elements + .range_checks + .rc_18 + .clone(), + range_check_11_lookup_elements: interaction_elements + .range_checks + .rc_11 + .clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let jnz = cairo_claim + .jnz + .iter() + .zip(interaction_claim.jnz.iter()) + .map(|(&claim, &interaction_claim)| { + jnz_opcode_non_taken::Component::new( + tree_span_provider, + jnz_opcode_non_taken::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let jnz_taken = cairo_claim + .jnz_taken + .iter() + .zip(interaction_claim.jnz_taken.iter()) + .map(|(&claim, &interaction_claim)| { + jnz_opcode_taken::Component::new( + tree_span_provider, + jnz_opcode_taken::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let jump = cairo_claim + .jump + .iter() + .zip(interaction_claim.jump.iter()) + .map(|(&claim, &interaction_claim)| { + jump_opcode_abs::Component::new( + tree_span_provider, + jump_opcode_abs::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let jump_double_deref = cairo_claim + .jump_double_deref + .iter() + .zip(interaction_claim.jump_double_deref.iter()) + .map(|(&claim, &interaction_claim)| { + jump_opcode_double_deref::Component::new( + tree_span_provider, + jump_opcode_double_deref::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let jump_rel = cairo_claim + .jump_rel + .iter() + .zip(interaction_claim.jump_rel.iter()) + .map(|(&claim, &interaction_claim)| { + jump_opcode_rel::Component::new( + tree_span_provider, + jump_opcode_rel::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let jump_rel_imm = cairo_claim + .jump_rel_imm + .iter() + .zip(interaction_claim.jump_rel_imm.iter()) + .map(|(&claim, &interaction_claim)| { + jump_opcode_rel_imm::Component::new( + tree_span_provider, + jump_opcode_rel_imm::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let mul = cairo_claim + .mul + .iter() + .zip(interaction_claim.mul.iter()) + .map(|(&claim, &interaction_claim)| { + mul_opcode::Component::new( + tree_span_provider, + mul_opcode::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + range_check_20_lookup_elements: interaction_elements + .range_checks + .rc_20 + .clone(), + range_check_20_b_lookup_elements: interaction_elements + .range_checks + .rc_20_b + .clone(), + range_check_20_c_lookup_elements: interaction_elements + .range_checks + .rc_20_c + .clone(), + range_check_20_d_lookup_elements: interaction_elements + .range_checks + .rc_20_d + .clone(), + range_check_20_e_lookup_elements: interaction_elements + .range_checks + .rc_20_e + .clone(), + range_check_20_f_lookup_elements: interaction_elements + .range_checks + .rc_20_f + .clone(), + range_check_20_g_lookup_elements: interaction_elements + .range_checks + .rc_20_g + .clone(), + range_check_20_h_lookup_elements: interaction_elements + .range_checks + .rc_20_h + .clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let mul_small = cairo_claim + .mul_small + .iter() + .zip(interaction_claim.mul_small.iter()) + .map(|(&claim, &interaction_claim)| { + mul_opcode_small::Component::new( + tree_span_provider, + mul_opcode_small::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + range_check_11_lookup_elements: interaction_elements + .range_checks + .rc_11 + .clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let qm31 = cairo_claim + .qm31 + .iter() + .zip(interaction_claim.qm31.iter()) + .map(|(&claim, &interaction_claim)| { + qm_31_add_mul_opcode::Component::new( + tree_span_provider, + qm_31_add_mul_opcode::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + range_check_4_4_4_4_lookup_elements: interaction_elements + .range_checks + .rc_4_4_4_4 + .clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); + let ret = cairo_claim + .ret + .iter() + .zip(interaction_claim.ret.iter()) + .map(|(&claim, &interaction_claim)| { + ret_opcode::Component::new( + tree_span_provider, + ret_opcode::Eval { + claim, + memory_address_to_id_lookup_elements: interaction_elements + .memory_address_to_id + .clone(), + memory_id_to_big_lookup_elements: interaction_elements + .memory_id_to_value + .clone(), + verify_instruction_lookup_elements: interaction_elements + .verify_instruction + .clone(), + opcodes_lookup_elements: interaction_elements.opcodes.clone(), + }, + interaction_claim.claimed_sum, + ) + }) + .collect(); let verify_instruction_component = verify_instruction::Component::new( tree_span_provider, @@ -193,7 +815,26 @@ impl CairoComponents { interaction_claim.verify_bitwise_xor_9.claimed_sum, ); Self { - opcodes: opcode_components, + add, + add_small, + add_ap, + assert_eq, + assert_eq_imm, + assert_eq_double_deref, + blake, + call, + call_rel_imm, + generic, + jnz, + jnz_taken, + jump, + jump_double_deref, + jump_rel, + jump_rel_imm, + mul, + mul_small, + qm31, + ret, verify_instruction: verify_instruction_component, blake_context, builtins: builtin_components, @@ -215,7 +856,66 @@ impl CairoComponents { pub fn provers(&self) -> Vec<&dyn ComponentProver> { chain!( - self.opcodes.provers(), + self.add + .iter() + .map(|c| c as &dyn ComponentProver), + self.add_small + .iter() + .map(|c| c as &dyn ComponentProver), + self.add_ap + .iter() + .map(|c| c as &dyn ComponentProver), + self.assert_eq + .iter() + .map(|c| c as &dyn ComponentProver), + self.assert_eq_imm + .iter() + .map(|c| c as &dyn ComponentProver), + self.assert_eq_double_deref + .iter() + .map(|c| c as &dyn ComponentProver), + self.blake + .iter() + .map(|c| c as &dyn ComponentProver), + self.call + .iter() + .map(|c| c as &dyn ComponentProver), + self.call_rel_imm + .iter() + .map(|c| c as &dyn ComponentProver), + self.generic + .iter() + .map(|c| c as &dyn ComponentProver), + self.jnz + .iter() + .map(|c| c as &dyn ComponentProver), + self.jnz_taken + .iter() + .map(|c| c as &dyn ComponentProver), + self.jump + .iter() + .map(|c| c as &dyn ComponentProver), + self.jump_double_deref + .iter() + .map(|c| c as &dyn ComponentProver), + self.jump_rel + .iter() + .map(|c| c as &dyn ComponentProver), + self.jump_rel_imm + .iter() + .map(|c| c as &dyn ComponentProver), + self.mul + .iter() + .map(|c| c as &dyn ComponentProver), + self.mul_small + .iter() + .map(|c| c as &dyn ComponentProver), + self.qm31 + .iter() + .map(|c| c as &dyn ComponentProver), + self.ret + .iter() + .map(|c| c as &dyn ComponentProver), [&self.verify_instruction as &dyn ComponentProver,], self.blake_context.provers(), self.builtins.provers(), @@ -250,7 +950,46 @@ impl CairoComponents { impl std::fmt::Display for CairoComponents { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { writeln!(f, "CairoComponents")?; - writeln!(f, "Opcodes: {}", self.opcodes)?; + writeln!(f, "add:\n{}", display_components(&self.add))?; + writeln!(f, "add_small:\n{}", display_components(&self.add_small))?; + writeln!(f, "add_ap:\n{}", display_components(&self.add_ap))?; + writeln!(f, "assert_eq:\n{}", display_components(&self.assert_eq))?; + writeln!( + f, + "assert_eq_imm:\n{}", + display_components(&self.assert_eq_imm) + )?; + writeln!( + f, + "assert_eq_double_deref:\n{}", + display_components(&self.assert_eq_double_deref) + )?; + writeln!(f, "blake:\n{}", display_components(&self.blake))?; + writeln!(f, "call:\n{}", display_components(&self.call))?; + writeln!( + f, + "call_rel_imm:\n{}", + display_components(&self.call_rel_imm) + )?; + writeln!(f, "generic:\n{}", display_components(&self.generic))?; + writeln!(f, "jnz:\n{}", display_components(&self.jnz))?; + writeln!(f, "jnz_taken:\n{}", display_components(&self.jnz_taken))?; + writeln!(f, "jump:\n{}", display_components(&self.jump))?; + writeln!( + f, + "jump_double_deref:\n{}", + display_components(&self.jump_double_deref) + )?; + writeln!(f, "jump_rel:\n{}", display_components(&self.jump_rel))?; + writeln!( + f, + "jump_rel_imm:\n{}", + display_components(&self.jump_rel_imm) + )?; + writeln!(f, "mul:\n{}", display_components(&self.mul))?; + writeln!(f, "mul_small:\n{}", display_components(&self.mul_small))?; + writeln!(f, "qm31:\n{}", display_components(&self.qm31))?; + writeln!(f, "ret:\n{}", display_components(&self.ret))?; writeln!( f, "VerifyInstruction: {}", diff --git a/stwo_cairo_prover/crates/cairo-air/src/cairo_interaction_claim.rs b/stwo_cairo_prover/crates/cairo-air/src/cairo_interaction_claim.rs index 830e1f5034..130d74ace6 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/cairo_interaction_claim.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/cairo_interaction_claim.rs @@ -1,25 +1,45 @@ -use serde::{Deserialize, Serialize}; use num_traits::Zero; +use serde::{Deserialize, Serialize}; use stwo::core::channel::Channel; use stwo::core::fields::qm31::{SecureField, QM31}; use stwo_cairo_serialize::{CairoDeserialize, CairoSerialize}; +use crate::blake::air::BlakeContextInteractionClaim; +use crate::builtins_air::BuiltinsInteractionClaim; use crate::cairo_claim::CairoClaim; use crate::cairo_interaction_elements::CairoInteractionElements; use crate::components::{ memory_address_to_id, memory_id_to_big, verify_bitwise_xor_4, verify_bitwise_xor_7, verify_bitwise_xor_8, verify_bitwise_xor_8_b, verify_bitwise_xor_9, verify_instruction, }; -use crate::opcodes_air::OpcodeInteractionClaim; -use crate::blake::air::BlakeContextInteractionClaim; -use crate::builtins_air::BuiltinsInteractionClaim; use crate::pedersen::air::PedersenContextInteractionClaim; use crate::poseidon::air::PoseidonContextInteractionClaim; use crate::range_checks_air::RangeChecksInteractionClaim; #[derive(Serialize, Deserialize, CairoSerialize, CairoDeserialize)] pub struct CairoInteractionClaim { - pub opcodes: OpcodeInteractionClaim, + // Inline opcode interaction claim vectors + pub add: Vec, + pub add_small: Vec, + pub add_ap: Vec, + pub assert_eq: Vec, + pub assert_eq_imm: Vec, + pub assert_eq_double_deref: + Vec, + pub blake: Vec, + pub call: Vec, + pub call_rel_imm: Vec, + pub generic: Vec, + pub jnz: Vec, + pub jnz_taken: Vec, + pub jump: Vec, + pub jump_double_deref: Vec, + pub jump_rel: Vec, + pub jump_rel_imm: Vec, + pub mul: Vec, + pub mul_small: Vec, + pub qm31: Vec, + pub ret: Vec, pub verify_instruction: verify_instruction::InteractionClaim, pub blake_context: BlakeContextInteractionClaim, pub builtins: BuiltinsInteractionClaim, @@ -36,7 +56,32 @@ pub struct CairoInteractionClaim { } impl CairoInteractionClaim { pub fn mix_into(&self, channel: &mut impl Channel) { - self.opcodes.mix_into(channel); + // Mix all opcode interaction claims + macro_rules! mix_vec { + ($field:ident) => { + self.$field.iter().for_each(|c| c.mix_into(channel)); + }; + } + mix_vec!(add); + mix_vec!(add_small); + mix_vec!(add_ap); + mix_vec!(assert_eq); + mix_vec!(assert_eq_imm); + mix_vec!(assert_eq_double_deref); + mix_vec!(blake); + mix_vec!(call); + mix_vec!(call_rel_imm); + mix_vec!(generic); + mix_vec!(jnz); + mix_vec!(jnz_taken); + mix_vec!(jump); + mix_vec!(jump_double_deref); + mix_vec!(jump_rel); + mix_vec!(jump_rel_imm); + mix_vec!(mul); + mix_vec!(mul_small); + mix_vec!(qm31); + mix_vec!(ret); self.verify_instruction.mix_into(channel); self.blake_context.mix_into(channel); self.builtins.mix_into(channel); @@ -63,7 +108,33 @@ pub fn lookup_sum( // If the table is padded, take the sum of the non-padded values. // Otherwise, the claimed_sum is the total_sum. - sum += interaction_claim.opcodes.sum(); + macro_rules! add_vec_sum { + ($field:ident) => { + for ic in &interaction_claim.$field { + sum += ic.claimed_sum; + } + }; + } + add_vec_sum!(add); + add_vec_sum!(add_small); + add_vec_sum!(add_ap); + add_vec_sum!(assert_eq); + add_vec_sum!(assert_eq_imm); + add_vec_sum!(assert_eq_double_deref); + add_vec_sum!(blake); + add_vec_sum!(call); + add_vec_sum!(call_rel_imm); + add_vec_sum!(generic); + add_vec_sum!(jnz); + add_vec_sum!(jnz_taken); + add_vec_sum!(jump); + add_vec_sum!(jump_double_deref); + add_vec_sum!(jump_rel); + add_vec_sum!(jump_rel_imm); + add_vec_sum!(mul); + add_vec_sum!(mul_small); + add_vec_sum!(qm31); + add_vec_sum!(ret); sum += interaction_claim.verify_instruction.claimed_sum; sum += interaction_claim.blake_context.sum(); sum += interaction_claim.builtins.sum(); diff --git a/stwo_cairo_prover/crates/cairo-air/src/lib.rs b/stwo_cairo_prover/crates/cairo-air/src/lib.rs index bf9debfe69..2f8da1ab39 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/lib.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/lib.rs @@ -4,16 +4,15 @@ use serde::{Deserialize, Serialize}; pub mod blake; pub mod builtins_air; -pub mod cairo_proof; -pub mod cairo_components; pub mod cairo_claim; -pub mod cairo_interaction_elements; -pub mod public_data; +pub mod cairo_components; pub mod cairo_interaction_claim; +pub mod cairo_interaction_elements; +pub mod cairo_proof; pub mod components; -pub mod opcodes_air; pub mod pedersen; pub mod poseidon; +pub mod public_data; pub mod range_checks_air; pub mod relations; pub mod utils; diff --git a/stwo_cairo_prover/crates/cairo-air/src/opcodes_air.rs b/stwo_cairo_prover/crates/cairo-air/src/opcodes_air.rs deleted file mode 100644 index 91bc8fed95..0000000000 --- a/stwo_cairo_prover/crates/cairo-air/src/opcodes_air.rs +++ /dev/null @@ -1,1085 +0,0 @@ -use itertools::{chain, Itertools}; -use num_traits::Zero; -use serde::{Deserialize, Serialize}; -use stwo::core::channel::Channel; -use stwo::core::fields::qm31::{SecureField, QM31}; -use stwo::core::pcs::TreeVec; -use stwo::prover::backend::simd::SimdBackend; -use stwo::prover::ComponentProver; -use stwo_cairo_serialize::{CairoDeserialize, CairoSerialize}; -use stwo_constraint_framework::TraceLocationAllocator; - -use crate::cairo_interaction_elements::CairoInteractionElements; -use super::components::display_components; -use crate::cairo_claim::{accumulate_relation_uses, RelationUsesDict}; -use crate::components::{ - add_ap_opcode, add_opcode, add_opcode_small, assert_eq_opcode, assert_eq_opcode_double_deref, - assert_eq_opcode_imm, blake_compress_opcode, call_opcode_abs, call_opcode_rel_imm, - generic_opcode, jnz_opcode_non_taken, jnz_opcode_taken, jump_opcode_abs, - jump_opcode_double_deref, jump_opcode_rel, jump_opcode_rel_imm, mul_opcode, mul_opcode_small, - qm_31_add_mul_opcode, ret_opcode, -}; - -#[derive(Serialize, Deserialize, CairoSerialize, CairoDeserialize)] -pub struct OpcodeClaim { - pub add: Vec, - pub add_small: Vec, - pub add_ap: Vec, - pub assert_eq: Vec, - pub assert_eq_imm: Vec, - pub assert_eq_double_deref: Vec, - pub blake: Vec, - pub call: Vec, - pub call_rel_imm: Vec, - pub generic: Vec, - pub jnz: Vec, - pub jnz_taken: Vec, - pub jump: Vec, - pub jump_double_deref: Vec, - pub jump_rel: Vec, - pub jump_rel_imm: Vec, - pub mul: Vec, - pub mul_small: Vec, - pub qm31: Vec, - pub ret: Vec, -} -impl OpcodeClaim { - /// For each opcode component vector, mixes the length and then the claims. - pub fn mix_into(&self, channel: &mut impl Channel) { - macro_rules! mix_component_vector { - ($field:ident) => { - channel.mix_u64(self.$field.len() as u64); - self.$field.iter().for_each(|c| c.mix_into(channel)); - }; - } - - mix_component_vector!(add); - mix_component_vector!(add_small); - mix_component_vector!(add_ap); - mix_component_vector!(assert_eq); - mix_component_vector!(assert_eq_imm); - mix_component_vector!(assert_eq_double_deref); - mix_component_vector!(blake); - mix_component_vector!(call); - mix_component_vector!(call_rel_imm); - mix_component_vector!(generic); - mix_component_vector!(jnz); - mix_component_vector!(jnz_taken); - mix_component_vector!(jump); - mix_component_vector!(jump_double_deref); - mix_component_vector!(jump_rel); - mix_component_vector!(jump_rel_imm); - mix_component_vector!(mul); - mix_component_vector!(mul_small); - mix_component_vector!(qm31); - mix_component_vector!(ret); - } - - pub fn log_sizes(&self) -> TreeVec> { - TreeVec::concat_cols(chain!( - self.add.iter().map(|c| c.log_sizes()), - self.add_small.iter().map(|c| c.log_sizes()), - self.add_ap.iter().map(|c| c.log_sizes()), - self.assert_eq.iter().map(|c| c.log_sizes()), - self.assert_eq_imm.iter().map(|c| c.log_sizes()), - self.assert_eq_double_deref.iter().map(|c| c.log_sizes()), - self.blake.iter().map(|c| c.log_sizes()), - self.call.iter().map(|c| c.log_sizes()), - self.call_rel_imm.iter().map(|c| c.log_sizes()), - self.generic.iter().map(|c| c.log_sizes()), - self.jnz.iter().map(|c| c.log_sizes()), - self.jnz_taken.iter().map(|c| c.log_sizes()), - self.jump.iter().map(|c| c.log_sizes()), - self.jump_double_deref.iter().map(|c| c.log_sizes()), - self.jump_rel.iter().map(|c| c.log_sizes()), - self.jump_rel_imm.iter().map(|c| c.log_sizes()), - self.mul.iter().map(|c| c.log_sizes()), - self.mul_small.iter().map(|c| c.log_sizes()), - self.qm31.iter().map(|c| c.log_sizes()), - self.ret.iter().map(|c| c.log_sizes()), - )) - } - - pub fn accumulate_relation_uses(&self, relation_uses: &mut RelationUsesDict) { - let Self { - add, - add_small, - add_ap, - assert_eq, - assert_eq_imm, - assert_eq_double_deref, - blake, - call, - call_rel_imm, - generic, - jnz, - jnz_taken, - jump, - jump_double_deref, - jump_rel, - jump_rel_imm, - mul, - mul_small, - qm31, - ret, - } = self; - - // TODO(alonf): canonicalize the name of field and module. - macro_rules! relation_uses { - ($field:ident, $module:ident) => { - $field.iter().for_each(|c| { - accumulate_relation_uses( - relation_uses, - $module::RELATION_USES_PER_ROW, - c.log_size, - ) - }); - }; - } - relation_uses!(add, add_opcode); - relation_uses!(add_small, add_opcode_small); - relation_uses!(add_ap, add_ap_opcode); - relation_uses!(assert_eq, assert_eq_opcode); - relation_uses!(assert_eq_imm, assert_eq_opcode_imm); - relation_uses!(assert_eq_double_deref, assert_eq_opcode_double_deref); - relation_uses!(blake, blake_compress_opcode); - relation_uses!(call, call_opcode_abs); - relation_uses!(call_rel_imm, call_opcode_rel_imm); - relation_uses!(generic, generic_opcode); - relation_uses!(jnz, jnz_opcode_non_taken); - relation_uses!(jnz_taken, jnz_opcode_taken); - relation_uses!(jump, jump_opcode_abs); - relation_uses!(jump_double_deref, jump_opcode_double_deref); - relation_uses!(jump_rel, jump_opcode_rel); - relation_uses!(jump_rel_imm, jump_opcode_rel_imm); - relation_uses!(mul, mul_opcode); - relation_uses!(mul_small, mul_opcode_small); - relation_uses!(qm31, qm_31_add_mul_opcode); - relation_uses!(ret, ret_opcode); - } -} - -#[derive(Serialize, Deserialize, CairoSerialize, CairoDeserialize)] -pub struct OpcodeInteractionClaim { - pub add: Vec, - pub add_small: Vec, - pub add_ap: Vec, - pub assert_eq: Vec, - pub assert_eq_imm: Vec, - pub assert_eq_double_deref: Vec, - pub blake: Vec, - pub call: Vec, - pub call_rel_imm: Vec, - pub generic: Vec, - pub jnz: Vec, - pub jnz_taken: Vec, - pub jump: Vec, - pub jump_double_deref: Vec, - pub jump_rel: Vec, - pub jump_rel_imm: Vec, - pub mul: Vec, - pub mul_small: Vec, - pub qm31: Vec, - pub ret: Vec, -} -impl OpcodeInteractionClaim { - pub fn mix_into(&self, channel: &mut impl Channel) { - self.add.iter().for_each(|c| c.mix_into(channel)); - self.add_small.iter().for_each(|c| c.mix_into(channel)); - self.add_ap.iter().for_each(|c| c.mix_into(channel)); - self.assert_eq.iter().for_each(|c| c.mix_into(channel)); - self.assert_eq_imm.iter().for_each(|c| c.mix_into(channel)); - self.assert_eq_double_deref - .iter() - .for_each(|c| c.mix_into(channel)); - self.blake.iter().for_each(|c| c.mix_into(channel)); - self.call.iter().for_each(|c| c.mix_into(channel)); - self.call_rel_imm.iter().for_each(|c| c.mix_into(channel)); - self.generic.iter().for_each(|c| c.mix_into(channel)); - self.jnz.iter().for_each(|c| c.mix_into(channel)); - self.jnz_taken.iter().for_each(|c| c.mix_into(channel)); - self.jump.iter().for_each(|c| c.mix_into(channel)); - self.jump_double_deref - .iter() - .for_each(|c| c.mix_into(channel)); - self.jump_rel.iter().for_each(|c| c.mix_into(channel)); - self.jump_rel_imm.iter().for_each(|c| c.mix_into(channel)); - self.mul.iter().for_each(|c| c.mix_into(channel)); - self.mul_small.iter().for_each(|c| c.mix_into(channel)); - self.qm31.iter().for_each(|c| c.mix_into(channel)); - self.ret.iter().for_each(|c| c.mix_into(channel)); - } - - pub fn sum(&self) -> SecureField { - let mut sum = QM31::zero(); - for interaction_claim in &self.add { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.add_small { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.add_ap { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.assert_eq { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.assert_eq_imm { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.assert_eq_double_deref { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.blake { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.call { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.call_rel_imm { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.generic { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.jnz { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.jnz_taken { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.jump { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.jump_double_deref { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.jump_rel { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.jump_rel_imm { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.mul { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.mul_small { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.qm31 { - sum += interaction_claim.claimed_sum; - } - for interaction_claim in &self.ret { - sum += interaction_claim.claimed_sum; - } - sum - } -} - -pub struct OpcodeComponents { - pub add: Vec, - pub add_small: Vec, - pub add_ap: Vec, - pub assert_eq: Vec, - pub assert_eq_imm: Vec, - pub assert_eq_double_deref: Vec, - pub blake: Vec, - pub call: Vec, - pub call_rel_imm: Vec, - pub generic: Vec, - pub jnz: Vec, - pub jnz_taken: Vec, - pub jump: Vec, - pub jump_double_deref: Vec, - pub jump_rel: Vec, - pub jump_rel_imm: Vec, - pub mul: Vec, - pub mul_small: Vec, - pub qm31: Vec, - pub ret: Vec, -} -impl OpcodeComponents { - pub fn new( - tree_span_provider: &mut TraceLocationAllocator, - claim: &OpcodeClaim, - interaction_elements: &CairoInteractionElements, - interaction_claim: &OpcodeInteractionClaim, - ) -> Self { - let add_components = claim - .add - .iter() - .zip(interaction_claim.add.iter()) - .map(|(&claim, &interaction_claim)| { - add_opcode::Component::new( - tree_span_provider, - add_opcode::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let add_small_components = claim - .add_small - .iter() - .zip(interaction_claim.add_small.iter()) - .map(|(&claim, &interaction_claim)| { - add_opcode_small::Component::new( - tree_span_provider, - add_opcode_small::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let add_ap_components = claim - .add_ap - .iter() - .zip(interaction_claim.add_ap.iter()) - .map(|(&claim, &interaction_claim)| { - add_ap_opcode::Component::new( - tree_span_provider, - add_ap_opcode::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - range_check_18_lookup_elements: interaction_elements - .range_checks - .rc_18 - .clone(), - range_check_11_lookup_elements: interaction_elements - .range_checks - .rc_11 - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let assert_eq_components = claim - .assert_eq - .iter() - .zip(interaction_claim.assert_eq.iter()) - .map(|(&claim, &interaction_claim)| { - assert_eq_opcode::Component::new( - tree_span_provider, - assert_eq_opcode::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let assert_eq_imm_components = claim - .assert_eq_imm - .iter() - .zip(interaction_claim.assert_eq_imm.iter()) - .map(|(&claim, &interaction_claim)| { - assert_eq_opcode_imm::Component::new( - tree_span_provider, - assert_eq_opcode_imm::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let assert_eq_double_deref_components = claim - .assert_eq_double_deref - .iter() - .zip(interaction_claim.assert_eq_double_deref.iter()) - .map(|(&claim, &interaction_claim)| { - assert_eq_opcode_double_deref::Component::new( - tree_span_provider, - assert_eq_opcode_double_deref::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let blake_components = claim - .blake - .iter() - .zip(interaction_claim.blake.iter()) - .map(|(&claim, &interaction_claim)| { - blake_compress_opcode::Component::new( - tree_span_provider, - blake_compress_opcode::Eval { - claim, - blake_round_lookup_elements: interaction_elements.blake_round.clone(), - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - range_check_7_2_5_lookup_elements: interaction_elements - .range_checks - .rc_7_2_5 - .clone(), - triple_xor_32_lookup_elements: interaction_elements.triple_xor_32.clone(), - verify_bitwise_xor_8_lookup_elements: interaction_elements - .verify_bitwise_xor_8 - .clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let call_components = claim - .call - .iter() - .zip(interaction_claim.call.iter()) - .map(|(&claim, &interaction_claim)| { - call_opcode_abs::Component::new( - tree_span_provider, - call_opcode_abs::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect(); - let call_rel_imm_components = claim - .call_rel_imm - .iter() - .zip(interaction_claim.call_rel_imm.iter()) - .map(|(&claim, &interaction_claim)| { - call_opcode_rel_imm::Component::new( - tree_span_provider, - call_opcode_rel_imm::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect(); - let generic_components = claim - .generic - .iter() - .zip(interaction_claim.generic.iter()) - .map(|(&claim, &interaction_claim)| { - generic_opcode::Component::new( - tree_span_provider, - generic_opcode::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - range_check_20_lookup_elements: interaction_elements - .range_checks - .rc_20 - .clone(), - range_check_20_b_lookup_elements: interaction_elements - .range_checks - .rc_20_b - .clone(), - range_check_20_c_lookup_elements: interaction_elements - .range_checks - .rc_20_c - .clone(), - range_check_20_d_lookup_elements: interaction_elements - .range_checks - .rc_20_d - .clone(), - range_check_20_e_lookup_elements: interaction_elements - .range_checks - .rc_20_e - .clone(), - range_check_20_f_lookup_elements: interaction_elements - .range_checks - .rc_20_f - .clone(), - range_check_20_g_lookup_elements: interaction_elements - .range_checks - .rc_20_g - .clone(), - range_check_20_h_lookup_elements: interaction_elements - .range_checks - .rc_20_h - .clone(), - range_check_9_9_lookup_elements: interaction_elements - .range_checks - .rc_9_9 - .clone(), - range_check_9_9_b_lookup_elements: interaction_elements - .range_checks - .rc_9_9_b - .clone(), - range_check_9_9_c_lookup_elements: interaction_elements - .range_checks - .rc_9_9_c - .clone(), - range_check_9_9_d_lookup_elements: interaction_elements - .range_checks - .rc_9_9_d - .clone(), - range_check_9_9_e_lookup_elements: interaction_elements - .range_checks - .rc_9_9_e - .clone(), - range_check_9_9_f_lookup_elements: interaction_elements - .range_checks - .rc_9_9_f - .clone(), - range_check_9_9_g_lookup_elements: interaction_elements - .range_checks - .rc_9_9_g - .clone(), - range_check_9_9_h_lookup_elements: interaction_elements - .range_checks - .rc_9_9_h - .clone(), - range_check_18_lookup_elements: interaction_elements - .range_checks - .rc_18 - .clone(), - range_check_11_lookup_elements: interaction_elements - .range_checks - .rc_11 - .clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let jnz_components = claim - .jnz - .iter() - .zip(interaction_claim.jnz.iter()) - .map(|(&claim, &interaction_claim)| { - jnz_opcode_non_taken::Component::new( - tree_span_provider, - jnz_opcode_non_taken::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let jnz_taken_components = claim - .jnz_taken - .iter() - .zip(interaction_claim.jnz_taken.iter()) - .map(|(&claim, &interaction_claim)| { - jnz_opcode_taken::Component::new( - tree_span_provider, - jnz_opcode_taken::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let jump_components = claim - .jump - .iter() - .zip(interaction_claim.jump.iter()) - .map(|(&claim, &interaction_claim)| { - jump_opcode_abs::Component::new( - tree_span_provider, - jump_opcode_abs::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect(); - let jump_double_deref_components = claim - .jump_double_deref - .iter() - .zip(interaction_claim.jump_double_deref.iter()) - .map(|(&claim, &interaction_claim)| { - jump_opcode_double_deref::Component::new( - tree_span_provider, - jump_opcode_double_deref::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect(); - let jump_rel_components = claim - .jump_rel - .iter() - .zip(interaction_claim.jump_rel.iter()) - .map(|(&claim, &interaction_claim)| { - jump_opcode_rel::Component::new( - tree_span_provider, - jump_opcode_rel::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect(); - let jump_rel_imm_components = claim - .jump_rel_imm - .iter() - .zip(interaction_claim.jump_rel_imm.iter()) - .map(|(&claim, &interaction_claim)| { - jump_opcode_rel_imm::Component::new( - tree_span_provider, - jump_opcode_rel_imm::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect(); - let mul_components = claim - .mul - .iter() - .zip(interaction_claim.mul.iter()) - .map(|(&claim, &interaction_claim)| { - mul_opcode::Component::new( - tree_span_provider, - mul_opcode::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - range_check_20_lookup_elements: interaction_elements - .range_checks - .rc_20 - .clone(), - range_check_20_b_lookup_elements: interaction_elements - .range_checks - .rc_20_b - .clone(), - range_check_20_c_lookup_elements: interaction_elements - .range_checks - .rc_20_c - .clone(), - range_check_20_d_lookup_elements: interaction_elements - .range_checks - .rc_20_d - .clone(), - range_check_20_e_lookup_elements: interaction_elements - .range_checks - .rc_20_e - .clone(), - range_check_20_f_lookup_elements: interaction_elements - .range_checks - .rc_20_f - .clone(), - range_check_20_g_lookup_elements: interaction_elements - .range_checks - .rc_20_g - .clone(), - range_check_20_h_lookup_elements: interaction_elements - .range_checks - .rc_20_h - .clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let mul_small_components = claim - .mul_small - .iter() - .zip(interaction_claim.mul_small.iter()) - .map(|(&claim, &interaction_claim)| { - mul_opcode_small::Component::new( - tree_span_provider, - mul_opcode_small::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - range_check_11_lookup_elements: interaction_elements - .range_checks - .rc_11 - .clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - let qm31_components = claim - .qm31 - .iter() - .zip(interaction_claim.qm31.iter()) - .map(|(&claim, &interaction_claim)| { - qm_31_add_mul_opcode::Component::new( - tree_span_provider, - qm_31_add_mul_opcode::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - range_check_4_4_4_4_lookup_elements: interaction_elements - .range_checks - .rc_4_4_4_4 - .clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect(); - let ret_components = claim - .ret - .iter() - .zip(interaction_claim.ret.iter()) - .map(|(&claim, &interaction_claim)| { - ret_opcode::Component::new( - tree_span_provider, - ret_opcode::Eval { - claim, - memory_address_to_id_lookup_elements: interaction_elements - .memory_address_to_id - .clone(), - memory_id_to_big_lookup_elements: interaction_elements - .memory_id_to_value - .clone(), - verify_instruction_lookup_elements: interaction_elements - .verify_instruction - .clone(), - opcodes_lookup_elements: interaction_elements.opcodes.clone(), - }, - interaction_claim.claimed_sum, - ) - }) - .collect_vec(); - Self { - add: add_components, - add_small: add_small_components, - add_ap: add_ap_components, - assert_eq: assert_eq_components, - assert_eq_imm: assert_eq_imm_components, - assert_eq_double_deref: assert_eq_double_deref_components, - blake: blake_components, - call: call_components, - call_rel_imm: call_rel_imm_components, - generic: generic_components, - jnz: jnz_components, - jnz_taken: jnz_taken_components, - jump: jump_components, - jump_double_deref: jump_double_deref_components, - jump_rel: jump_rel_components, - jump_rel_imm: jump_rel_imm_components, - mul: mul_components, - mul_small: mul_small_components, - qm31: qm31_components, - ret: ret_components, - } - } - - pub fn provers(&self) -> Vec<&dyn ComponentProver> { - let mut vec: Vec<&dyn ComponentProver> = vec![]; - vec.extend( - self.add - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.add_small - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.add_ap - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.assert_eq - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.assert_eq_imm - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.assert_eq_double_deref - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.blake - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.call - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.call_rel_imm - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.generic - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.jnz - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.jnz_taken - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.jump - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.jump_double_deref - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.jump_rel - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.jump_rel_imm - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.mul - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.mul_small - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.qm31 - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec.extend( - self.ret - .iter() - .map(|component| component as &dyn ComponentProver), - ); - vec - } -} - -impl std::fmt::Display for OpcodeComponents { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - writeln!(f, "add:")?; - writeln!(f, "{}", display_components(&self.add))?; - writeln!(f, "add_small:")?; - writeln!(f, "{}", display_components(&self.add_small))?; - writeln!(f, "add_ap:")?; - writeln!(f, "{}", display_components(&self.add_ap))?; - writeln!(f, "assert_eq:")?; - writeln!(f, "{}", display_components(&self.assert_eq))?; - writeln!(f, "assert_eq_imm:")?; - writeln!(f, "{}", display_components(&self.assert_eq_imm))?; - writeln!(f, "assert_eq_double_deref:")?; - writeln!(f, "{}", display_components(&self.assert_eq_double_deref))?; - writeln!(f, "blake:")?; - writeln!(f, "{}", display_components(&self.blake))?; - writeln!(f, "call:")?; - writeln!(f, "{}", display_components(&self.call))?; - writeln!(f, "call_rel_imm:")?; - writeln!(f, "{}", display_components(&self.call_rel_imm))?; - writeln!(f, "generic:")?; - writeln!(f, "{}", display_components(&self.generic))?; - writeln!(f, "jnz:")?; - writeln!(f, "{}", display_components(&self.jnz))?; - writeln!(f, "jnz_taken:")?; - writeln!(f, "{}", display_components(&self.jnz_taken))?; - writeln!(f, "jump:")?; - writeln!(f, "{}", display_components(&self.jump))?; - writeln!(f, "jump_double_deref:")?; - writeln!(f, "{}", display_components(&self.jump_double_deref))?; - writeln!(f, "jump_rel:")?; - writeln!(f, "{}", display_components(&self.jump_rel))?; - writeln!(f, "jump_rel_imm:")?; - writeln!(f, "{}", display_components(&self.jump_rel_imm))?; - writeln!(f, "mul:")?; - writeln!(f, "{}", display_components(&self.mul))?; - writeln!(f, "mul_small:")?; - writeln!(f, "{}", display_components(&self.mul_small))?; - writeln!(f, "qm31:")?; - writeln!(f, "{}", display_components(&self.qm31))?; - writeln!(f, "ret:")?; - writeln!(f, "{}", display_components(&self.ret))?; - Ok(()) - } -} diff --git a/stwo_cairo_prover/crates/cairo-air/src/pedersen/air.rs b/stwo_cairo_prover/crates/cairo-air/src/pedersen/air.rs index 88019b9eb4..1bfc40a25b 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/pedersen/air.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/pedersen/air.rs @@ -4,8 +4,8 @@ use stwo::prover::backend::simd::SimdBackend; use stwo::prover::ComponentProver; use stwo_constraint_framework::TraceLocationAllocator; -use crate::cairo_interaction_elements::CairoInteractionElements; use crate::cairo_claim::{accumulate_relation_uses, RelationUsesDict}; +use crate::cairo_interaction_elements::CairoInteractionElements; use crate::components::prelude::*; use crate::components::{indented_component_display, partial_ec_mul, pedersen_points_table}; diff --git a/stwo_cairo_prover/crates/cairo-air/src/poseidon/air.rs b/stwo_cairo_prover/crates/cairo-air/src/poseidon/air.rs index e1610cc9a6..76f5464659 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/poseidon/air.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/poseidon/air.rs @@ -4,8 +4,8 @@ use stwo::prover::backend::simd::SimdBackend; use stwo::prover::ComponentProver; use stwo_constraint_framework::TraceLocationAllocator; -use crate::cairo_interaction_elements::CairoInteractionElements; use crate::cairo_claim::{accumulate_relation_uses, RelationUsesDict}; +use crate::cairo_interaction_elements::CairoInteractionElements; use crate::components::prelude::*; use crate::components::{ cube_252, indented_component_display, poseidon_3_partial_rounds_chain, diff --git a/stwo_cairo_prover/crates/cairo-air/src/verifier.rs b/stwo_cairo_prover/crates/cairo-air/src/verifier.rs index 6203fcfbb8..41d1d1f404 100644 --- a/stwo_cairo_prover/crates/cairo-air/src/verifier.rs +++ b/stwo_cairo_prover/crates/cairo-air/src/verifier.rs @@ -22,9 +22,10 @@ use crate::cairo_claim::CairoClaim; use crate::cairo_components::CairoComponents; use crate::cairo_interaction_claim::lookup_sum; use crate::cairo_interaction_elements::CairoInteractionElements; -use crate::public_data::{MemorySection, PublicMemory, PublicSegmentRanges, SegmentRange}; -use crate::public_data::PublicData; use crate::components::memory_address_to_id::MEMORY_ADDRESS_TO_ID_SPLIT; +use crate::public_data::{ + MemorySection, PublicData, PublicMemory, PublicSegmentRanges, SegmentRange, +}; use crate::{CairoProof, PreProcessedTraceVariant}; fn verify_claim(claim: &CairoClaim) { diff --git a/stwo_cairo_prover/crates/prover/src/debug_tools/assert_constraints.rs b/stwo_cairo_prover/crates/prover/src/debug_tools/assert_constraints.rs index da23b5be6e..8068097c03 100644 --- a/stwo_cairo_prover/crates/prover/src/debug_tools/assert_constraints.rs +++ b/stwo_cairo_prover/crates/prover/src/debug_tools/assert_constraints.rs @@ -3,7 +3,6 @@ use std::ops::Deref; use cairo_air::builtins_air::BuiltinComponents; use cairo_air::cairo_components::CairoComponents; use cairo_air::cairo_interaction_elements::CairoInteractionElements; -use cairo_air::opcodes_air::OpcodeComponents; use cairo_air::range_checks_air::RangeChecksComponents; use itertools::Itertools; use stwo::core::channel::Blake2sChannel; @@ -52,22 +51,6 @@ pub fn assert_component( // * `cairo_components` - The components constraints to check. fn assert_cairo_components(trace: TreeVec>>, cairo_components: &CairoComponents) { let CairoComponents { - opcodes, - verify_instruction, - blake_context, - builtins, - pedersen_context, - poseidon_context, - memory_address_to_id, - memory_id_to_value, - range_checks, - verify_bitwise_xor_4, - verify_bitwise_xor_7, - verify_bitwise_xor_8, - verify_bitwise_xor_8_b, - verify_bitwise_xor_9, - } = cairo_components; - let OpcodeComponents { add, add_small, add_ap, @@ -88,7 +71,20 @@ fn assert_cairo_components(trace: TreeVec>>, cairo_components: &Ca mul_small, qm31, ret, - } = opcodes; + verify_instruction, + blake_context, + builtins, + pedersen_context, + poseidon_context, + memory_address_to_id, + memory_id_to_value, + range_checks, + verify_bitwise_xor_4, + verify_bitwise_xor_7, + verify_bitwise_xor_8, + verify_bitwise_xor_8_b, + verify_bitwise_xor_9, + } = cairo_components; let RangeChecksComponents { rc_6, rc_8, diff --git a/stwo_cairo_prover/crates/prover/src/debug_tools/relation_tracker.rs b/stwo_cairo_prover/crates/prover/src/debug_tools/relation_tracker.rs index 87a84d49a2..a1c7232480 100644 --- a/stwo_cairo_prover/crates/prover/src/debug_tools/relation_tracker.rs +++ b/stwo_cairo_prover/crates/prover/src/debug_tools/relation_tracker.rs @@ -1,7 +1,6 @@ +use cairo_air::builtins_air::BuiltinComponents; use cairo_air::cairo_components::CairoComponents; use cairo_air::public_data::PublicData; -use cairo_air::builtins_air::BuiltinComponents; -use cairo_air::opcodes_air::OpcodeComponents; use cairo_air::range_checks_air::RangeChecksComponents; use itertools::{chain, Itertools}; use num_traits::{One, Zero}; @@ -101,22 +100,6 @@ fn cairo_relation_entries( trace: &TreeVec>>, ) -> Vec { let CairoComponents { - opcodes, - verify_instruction, - blake_context, - builtins, - memory_address_to_id, - memory_id_to_value, - range_checks, - verify_bitwise_xor_4, - verify_bitwise_xor_7, - verify_bitwise_xor_8, - verify_bitwise_xor_8_b, - verify_bitwise_xor_9, - pedersen_context, - poseidon_context, - } = cairo_components; - let OpcodeComponents { add, add_small, add_ap, @@ -137,7 +120,20 @@ fn cairo_relation_entries( mul_small, qm31, ret, - } = opcodes; + verify_instruction, + blake_context, + builtins, + memory_address_to_id, + memory_id_to_value, + range_checks, + verify_bitwise_xor_4, + verify_bitwise_xor_7, + verify_bitwise_xor_8, + verify_bitwise_xor_8_b, + verify_bitwise_xor_9, + pedersen_context, + poseidon_context, + } = cairo_components; let RangeChecksComponents { rc_6, diff --git a/stwo_cairo_prover/crates/prover/src/witness/cairo.rs b/stwo_cairo_prover/crates/prover/src/witness/cairo.rs index 1ae945c6fb..54974e278b 100644 --- a/stwo_cairo_prover/crates/prover/src/witness/cairo.rs +++ b/stwo_cairo_prover/crates/prover/src/witness/cairo.rs @@ -3,7 +3,9 @@ use std::array; use cairo_air::cairo_claim::CairoClaim; use cairo_air::cairo_interaction_claim::CairoInteractionClaim; use cairo_air::cairo_interaction_elements::CairoInteractionElements; -use cairo_air::public_data::{MemorySmallValue, PublicData, PublicMemory, PublicSegmentRanges, SegmentRange}; +use cairo_air::public_data::{ + MemorySmallValue, PublicData, PublicMemory, PublicSegmentRanges, SegmentRange, +}; use itertools::Itertools; use stwo::core::fields::m31::M31; use stwo::prover::backend::simd::SimdBackend; @@ -14,7 +16,6 @@ use tracing::{span, Level}; use super::blake_context::{BlakeContextClaimGenerator, BlakeContextInteractionClaimGenerator}; use super::builtins::{BuiltinsClaimGenerator, BuiltinsInteractionClaimGenerator}; -use super::opcodes::{OpcodesClaimGenerator, OpcodesInteractionClaimGenerator}; use super::range_checks::{RangeChecksClaimGenerator, RangeChecksInteractionClaimGenerator}; use crate::witness::components::pedersen::{ PedersenContextClaimGenerator, PedersenContextInteractionClaimGenerator, @@ -23,8 +24,13 @@ use crate::witness::components::poseidon::{ PoseidonContextClaimGenerator, PoseidonContextInteractionClaimGenerator, }; use crate::witness::components::{ - memory_address_to_id, memory_id_to_big, verify_bitwise_xor_4, verify_bitwise_xor_7, - verify_bitwise_xor_8, verify_bitwise_xor_8_b, verify_bitwise_xor_9, verify_instruction, + add_ap_opcode, add_opcode, add_opcode_small, assert_eq_opcode, assert_eq_opcode_double_deref, + assert_eq_opcode_imm, blake_compress_opcode, call_opcode_abs, call_opcode_rel_imm, + generic_opcode, jnz_opcode_non_taken, jnz_opcode_taken, jump_opcode_abs, + jump_opcode_double_deref, jump_opcode_rel, jump_opcode_rel_imm, memory_address_to_id, + memory_id_to_big, mul_opcode, mul_opcode_small, qm_31_add_mul_opcode, ret_opcode, + verify_bitwise_xor_4, verify_bitwise_xor_7, verify_bitwise_xor_8, verify_bitwise_xor_8_b, + verify_bitwise_xor_9, verify_instruction, }; use crate::witness::utils::TreeBuilder; @@ -122,7 +128,27 @@ fn extract_sections_from_memory( pub struct CairoClaimGenerator { public_data: PublicData, - opcodes: OpcodesClaimGenerator, + // Opcode claim generators (inlined former OpcodesClaimGenerator) + add: Vec, + add_small: Vec, + add_ap: Vec, + assert_eq: Vec, + assert_eq_imm: Vec, + assert_eq_double_deref: Vec, + blake: Vec, + call: Vec, + call_rel_imm: Vec, + generic: Vec, + jnz: Vec, + jnz_taken: Vec, + jump: Vec, + jump_double_deref: Vec, + jump_rel: Vec, + jump_rel_imm: Vec, + mul: Vec, + mul_small: Vec, + qm31: Vec, + ret: Vec, // Internal components. verify_instruction_trace_generator: verify_instruction::ClaimGenerator, @@ -153,7 +179,214 @@ impl CairoClaimGenerator { ) -> Self { let initial_state = state_transitions.initial_state; let final_state = state_transitions.final_state; - let opcodes = OpcodesClaimGenerator::new(state_transitions); + // Build opcode claim generators (inlined former OpcodesClaimGenerator::new) + // TODO(Ohad): decide split sizes for opcode traces. + let mut add = vec![]; + let mut add_small = vec![]; + let mut add_ap = vec![]; + let mut assert_eq = vec![]; + let mut assert_eq_imm = vec![]; + let mut assert_eq_double_deref = vec![]; + let mut blake = vec![]; + let mut call = vec![]; + let mut call_rel_imm = vec![]; + let mut generic = vec![]; + let mut jnz = vec![]; + let mut jnz_taken = vec![]; + let mut jump = vec![]; + let mut jump_double_deref = vec![]; + let mut jump_rel = vec![]; + let mut jump_rel_imm = vec![]; + let mut mul = vec![]; + let mut mul_small = vec![]; + let mut qm31 = vec![]; + let mut ret = vec![]; + if !state_transitions + .casm_states_by_opcode + .add_opcode + .is_empty() + { + add.push(add_opcode::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.add_opcode, + )); + } + if !state_transitions + .casm_states_by_opcode + .add_opcode_small + .is_empty() + { + add_small.push(add_opcode_small::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.add_opcode_small, + )); + } + if !state_transitions + .casm_states_by_opcode + .add_ap_opcode + .is_empty() + { + add_ap.push(add_ap_opcode::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.add_ap_opcode, + )); + } + if !state_transitions + .casm_states_by_opcode + .assert_eq_opcode + .is_empty() + { + assert_eq.push(assert_eq_opcode::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.assert_eq_opcode, + )); + } + if !state_transitions + .casm_states_by_opcode + .assert_eq_opcode_imm + .is_empty() + { + assert_eq_imm.push(assert_eq_opcode_imm::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.assert_eq_opcode_imm, + )); + } + if !state_transitions + .casm_states_by_opcode + .assert_eq_opcode_double_deref + .is_empty() + { + assert_eq_double_deref.push(assert_eq_opcode_double_deref::ClaimGenerator::new( + state_transitions + .casm_states_by_opcode + .assert_eq_opcode_double_deref, + )); + } + if !state_transitions + .casm_states_by_opcode + .blake_compress_opcode + .is_empty() + { + blake.push(blake_compress_opcode::ClaimGenerator::new( + state_transitions + .casm_states_by_opcode + .blake_compress_opcode, + )); + } + if !state_transitions + .casm_states_by_opcode + .call_opcode_abs + .is_empty() + { + call.push(call_opcode_abs::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.call_opcode_abs, + )); + } + if !state_transitions + .casm_states_by_opcode + .call_opcode_rel_imm + .is_empty() + { + call_rel_imm.push(call_opcode_rel_imm::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.call_opcode_rel_imm, + )); + } + if !state_transitions + .casm_states_by_opcode + .generic_opcode + .is_empty() + { + generic.push(generic_opcode::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.generic_opcode, + )); + } + if !state_transitions + .casm_states_by_opcode + .jnz_opcode_non_taken + .is_empty() + { + jnz.push(jnz_opcode_non_taken::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.jnz_opcode_non_taken, + )); + } + if !state_transitions + .casm_states_by_opcode + .jnz_opcode_taken + .is_empty() + { + jnz_taken.push(jnz_opcode_taken::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.jnz_opcode_taken, + )); + } + if !state_transitions + .casm_states_by_opcode + .jump_opcode_abs + .is_empty() + { + jump.push(jump_opcode_abs::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.jump_opcode_abs, + )); + } + if !state_transitions + .casm_states_by_opcode + .jump_opcode_double_deref + .is_empty() + { + jump_double_deref.push(jump_opcode_double_deref::ClaimGenerator::new( + state_transitions + .casm_states_by_opcode + .jump_opcode_double_deref, + )); + } + if !state_transitions + .casm_states_by_opcode + .jump_opcode_rel + .is_empty() + { + jump_rel.push(jump_opcode_rel::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.jump_opcode_rel, + )); + } + if !state_transitions + .casm_states_by_opcode + .jump_opcode_rel_imm + .is_empty() + { + jump_rel_imm.push(jump_opcode_rel_imm::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.jump_opcode_rel_imm, + )); + } + if !state_transitions + .casm_states_by_opcode + .mul_opcode + .is_empty() + { + mul.push(mul_opcode::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.mul_opcode, + )); + } + if !state_transitions + .casm_states_by_opcode + .mul_opcode_small + .is_empty() + { + mul_small.push(mul_opcode_small::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.mul_opcode_small, + )); + } + if !state_transitions + .casm_states_by_opcode + .qm_31_add_mul_opcode + .is_empty() + { + qm31.push(qm_31_add_mul_opcode::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.qm_31_add_mul_opcode, + )); + } + if !state_transitions + .casm_states_by_opcode + .ret_opcode + .is_empty() + { + ret.push(ret_opcode::ClaimGenerator::new( + state_transitions.casm_states_by_opcode.ret_opcode, + )); + } let verify_instruction_trace_generator = verify_instruction::ClaimGenerator::new(); let builtins = BuiltinsClaimGenerator::new(builtin_segments); let pedersen_context_trace_generator = PedersenContextClaimGenerator::new(); @@ -201,7 +434,26 @@ impl CairoClaimGenerator { Self { public_data, - opcodes, + add, + add_small, + add_ap, + assert_eq, + assert_eq_imm, + assert_eq_double_deref, + blake, + call, + call_rel_imm, + generic, + jnz, + jnz_taken, + jump, + jump_double_deref, + jump_rel, + jump_rel_imm, + mul, + mul_small, + qm31, + ret, verify_instruction_trace_generator, blake_context_trace_generator, builtins, @@ -223,15 +475,281 @@ impl CairoClaimGenerator { tree_builder: &mut impl TreeBuilder, ) -> (CairoClaim, CairoInteractionClaimGenerator) { let span = span!(Level::INFO, "write opcode trace").entered(); - let (opcodes_claim, opcodes_interaction_gen) = self.opcodes.write_trace( - tree_builder, - &mut self.blake_context_trace_generator, - &self.memory_address_to_id_trace_generator, - &self.memory_id_to_value_trace_generator, - &self.range_checks_trace_generator, - &self.verify_instruction_trace_generator, - &mut self.verify_bitwise_xor_8_trace_generator, - ); + // Inline write_trace for opcodes (former OpcodesClaimGenerator::write_trace) + let (add, add_interaction_gens) = self + .add + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (add_small, add_small_interaction_gens) = self + .add_small + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (add_ap, add_ap_interaction_gens) = self + .add_ap + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + &self.range_checks_trace_generator.rc_18_trace_generator, + &self.range_checks_trace_generator.rc_11_trace_generator, + ) + }) + .unzip(); + let (assert_eq, assert_eq_interaction_gens) = self + .assert_eq + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (assert_eq_imm, assert_eq_imm_interaction_gens) = self + .assert_eq_imm + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (assert_eq_double_deref, assert_eq_double_deref_interaction_gens) = self + .assert_eq_double_deref + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (blake, blake_interaction_gens) = self + .blake + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + &self.range_checks_trace_generator.rc_7_2_5_trace_generator, + &self.verify_bitwise_xor_8_trace_generator, + &mut self.blake_context_trace_generator.blake_round, + &mut self.blake_context_trace_generator.triple_xor_32, + ) + }) + .unzip(); + let (call, call_interaction_gens) = self + .call + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (call_rel_imm, call_rel_imm_interaction_gens) = self + .call_rel_imm + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (generic, generic_opcode_interaction_gens) = self + .generic + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + &self.range_checks_trace_generator.rc_9_9_trace_generator, + &self.range_checks_trace_generator.rc_9_9_b_trace_generator, + &self.range_checks_trace_generator.rc_9_9_c_trace_generator, + &self.range_checks_trace_generator.rc_9_9_d_trace_generator, + &self.range_checks_trace_generator.rc_9_9_e_trace_generator, + &self.range_checks_trace_generator.rc_9_9_f_trace_generator, + &self.range_checks_trace_generator.rc_9_9_g_trace_generator, + &self.range_checks_trace_generator.rc_9_9_h_trace_generator, + &self.range_checks_trace_generator.rc_20_trace_generator, + &self.range_checks_trace_generator.rc_20_b_trace_generator, + &self.range_checks_trace_generator.rc_20_c_trace_generator, + &self.range_checks_trace_generator.rc_20_d_trace_generator, + &self.range_checks_trace_generator.rc_20_e_trace_generator, + &self.range_checks_trace_generator.rc_20_f_trace_generator, + &self.range_checks_trace_generator.rc_20_g_trace_generator, + &self.range_checks_trace_generator.rc_20_h_trace_generator, + &self.range_checks_trace_generator.rc_18_trace_generator, + &self.range_checks_trace_generator.rc_11_trace_generator, + ) + }) + .unzip(); + let (jnz, jnz_interaction_gens) = self + .jnz + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (jnz_taken, jnz_taken_interaction_gens) = self + .jnz_taken + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (jump, jump_interaction_gens) = self + .jump + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (jump_double_deref, jump_double_deref_interaction_gens) = self + .jump_double_deref + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (jump_rel, jump_rel_interaction_gens) = self + .jump_rel + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (jump_rel_imm, jump_rel_imm_interaction_gens) = self + .jump_rel_imm + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); + let (mul, mul_interaction_gens) = self + .mul + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + &self.range_checks_trace_generator.rc_20_trace_generator, + &self.range_checks_trace_generator.rc_20_b_trace_generator, + &self.range_checks_trace_generator.rc_20_c_trace_generator, + &self.range_checks_trace_generator.rc_20_d_trace_generator, + &self.range_checks_trace_generator.rc_20_e_trace_generator, + &self.range_checks_trace_generator.rc_20_f_trace_generator, + &self.range_checks_trace_generator.rc_20_g_trace_generator, + &self.range_checks_trace_generator.rc_20_h_trace_generator, + ) + }) + .unzip(); + let (mul_small, mul_small_interaction_gens) = self + .mul_small + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + &self.range_checks_trace_generator.rc_11_trace_generator, + ) + }) + .unzip(); + let (qm31, qm31_interaction_gens) = self + .qm31 + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + &self.range_checks_trace_generator.rc_4_4_4_4_trace_generator, + ) + }) + .unzip(); + let (ret, ret_interaction_gens) = self + .ret + .into_iter() + .map(|gen| { + gen.write_trace( + tree_builder, + &self.memory_address_to_id_trace_generator, + &self.memory_id_to_value_trace_generator, + &self.verify_instruction_trace_generator, + ) + }) + .unzip(); span.exit(); let span = span!(Level::INFO, "internal component trace").entered(); let (verify_instruction_claim, verify_instruction_interaction_gen) = @@ -320,7 +838,26 @@ impl CairoClaimGenerator { ( CairoClaim { public_data: self.public_data, - opcodes: opcodes_claim, + add, + add_small, + add_ap, + assert_eq, + assert_eq_imm, + assert_eq_double_deref, + blake, + call, + call_rel_imm, + generic, + jnz, + jnz_taken, + jump, + jump_double_deref, + jump_rel, + jump_rel_imm, + mul, + mul_small, + qm31, + ret, verify_instruction: verify_instruction_claim, blake_context: blake_context_claim, builtins: builtins_claim, @@ -336,7 +873,26 @@ impl CairoClaimGenerator { verify_bitwise_xor_9: verify_bitwise_xor_9_claim, }, CairoInteractionClaimGenerator { - opcodes_interaction_gen, + add: add_interaction_gens, + add_small: add_small_interaction_gens, + add_ap: add_ap_interaction_gens, + assert_eq: assert_eq_interaction_gens, + assert_eq_imm: assert_eq_imm_interaction_gens, + assert_eq_double_deref: assert_eq_double_deref_interaction_gens, + blake: blake_interaction_gens, + call: call_interaction_gens, + call_rel_imm: call_rel_imm_interaction_gens, + generic_opcode_interaction_gens, + jnz: jnz_interaction_gens, + jnz_taken: jnz_taken_interaction_gens, + jump: jump_interaction_gens, + jump_double_deref: jump_double_deref_interaction_gens, + jump_rel: jump_rel_interaction_gens, + jump_rel_imm: jump_rel_imm_interaction_gens, + mul: mul_interaction_gens, + mul_small: mul_small_interaction_gens, + qm31: qm31_interaction_gens, + ret_interaction_gens, verify_instruction_interaction_gen, blake_context_interaction_gen, builtins_interaction_gen, @@ -356,7 +912,27 @@ impl CairoClaimGenerator { } pub struct CairoInteractionClaimGenerator { - opcodes_interaction_gen: OpcodesInteractionClaimGenerator, + // Opcode interaction claim generators (inlined former OpcodesInteractionClaimGenerator) + add: Vec, + add_small: Vec, + add_ap: Vec, + assert_eq: Vec, + assert_eq_imm: Vec, + assert_eq_double_deref: Vec, + blake: Vec, + call: Vec, + call_rel_imm: Vec, + generic_opcode_interaction_gens: Vec, + jnz: Vec, + jnz_taken: Vec, + jump: Vec, + jump_double_deref: Vec, + jump_rel: Vec, + jump_rel_imm: Vec, + mul: Vec, + mul_small: Vec, + qm31: Vec, + ret_interaction_gens: Vec, verify_instruction_interaction_gen: verify_instruction::InteractionClaimGenerator, blake_context_interaction_gen: BlakeContextInteractionClaimGenerator, builtins_interaction_gen: BuiltinsInteractionClaimGenerator, @@ -378,9 +954,299 @@ impl CairoInteractionClaimGenerator { tree_builder: &mut impl TreeBuilder, interaction_elements: &CairoInteractionElements, ) -> CairoInteractionClaim { - let opcodes_interaction_claims = self - .opcodes_interaction_gen - .write_interaction_trace(tree_builder, interaction_elements); + // Inline write_interaction_trace for opcodes + let add = self + .add + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let add_small = self + .add_small + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let add_ap = self + .add_ap + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.range_checks.rc_18, + &interaction_elements.range_checks.rc_11, + &interaction_elements.opcodes, + ) + }) + .collect(); + let assert_eq = self + .assert_eq + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.opcodes, + ) + }) + .collect(); + let assert_eq_imm = self + .assert_eq_imm + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.opcodes, + ) + }) + .collect(); + let assert_eq_double_deref = self + .assert_eq_double_deref + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let blake = self + .blake + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.range_checks.rc_7_2_5, + &interaction_elements.verify_bitwise_xor_8, + &interaction_elements.blake_round, + &interaction_elements.triple_xor_32, + &interaction_elements.opcodes, + ) + }) + .collect(); + let call = self + .call + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let call_rel_imm = self + .call_rel_imm + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let generic = self + .generic_opcode_interaction_gens + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.range_checks.rc_9_9, + &interaction_elements.range_checks.rc_9_9_b, + &interaction_elements.range_checks.rc_9_9_c, + &interaction_elements.range_checks.rc_9_9_d, + &interaction_elements.range_checks.rc_9_9_e, + &interaction_elements.range_checks.rc_9_9_f, + &interaction_elements.range_checks.rc_9_9_g, + &interaction_elements.range_checks.rc_9_9_h, + &interaction_elements.range_checks.rc_20, + &interaction_elements.range_checks.rc_20_b, + &interaction_elements.range_checks.rc_20_c, + &interaction_elements.range_checks.rc_20_d, + &interaction_elements.range_checks.rc_20_e, + &interaction_elements.range_checks.rc_20_f, + &interaction_elements.range_checks.rc_20_g, + &interaction_elements.range_checks.rc_20_h, + &interaction_elements.range_checks.rc_18, + &interaction_elements.range_checks.rc_11, + &interaction_elements.opcodes, + ) + }) + .collect(); + let jnz = self + .jnz + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let jnz_taken = self + .jnz_taken + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let jump = self + .jump + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let jump_double_deref = self + .jump_double_deref + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let jump_rel = self + .jump_rel + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let jump_rel_imm = self + .jump_rel_imm + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); + let mul = self + .mul + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.range_checks.rc_20, + &interaction_elements.range_checks.rc_20_b, + &interaction_elements.range_checks.rc_20_c, + &interaction_elements.range_checks.rc_20_d, + &interaction_elements.range_checks.rc_20_e, + &interaction_elements.range_checks.rc_20_f, + &interaction_elements.range_checks.rc_20_g, + &interaction_elements.range_checks.rc_20_h, + &interaction_elements.opcodes, + ) + }) + .collect(); + let mul_small = self + .mul_small + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.range_checks.rc_11, + &interaction_elements.opcodes, + ) + }) + .collect(); + let qm31 = self + .qm31 + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.range_checks.rc_4_4_4_4, + &interaction_elements.opcodes, + ) + }) + .collect(); + let ret = self + .ret_interaction_gens + .into_iter() + .map(|gen| { + gen.write_interaction_trace( + tree_builder, + &interaction_elements.verify_instruction, + &interaction_elements.memory_address_to_id, + &interaction_elements.memory_id_to_value, + &interaction_elements.opcodes, + ) + }) + .collect(); let verify_instruction_interaction_claim = self .verify_instruction_interaction_gen .write_interaction_trace( @@ -441,7 +1307,26 @@ impl CairoInteractionClaimGenerator { .write_interaction_trace(tree_builder, &interaction_elements.verify_bitwise_xor_9); CairoInteractionClaim { - opcodes: opcodes_interaction_claims, + add, + add_small, + add_ap, + assert_eq, + assert_eq_imm, + assert_eq_double_deref, + blake, + call, + call_rel_imm, + generic, + jnz, + jnz_taken, + jump, + jump_double_deref, + jump_rel, + jump_rel_imm, + mul, + mul_small, + qm31, + ret, verify_instruction: verify_instruction_interaction_claim, blake_context: blake_context_interaction_claim, builtins: builtins_interaction_claims, diff --git a/stwo_cairo_prover/crates/prover/src/witness/components/memory_id_to_big.rs b/stwo_cairo_prover/crates/prover/src/witness/components/memory_id_to_big.rs index 914d399bdb..fac5b9cfe3 100644 --- a/stwo_cairo_prover/crates/prover/src/witness/components/memory_id_to_big.rs +++ b/stwo_cairo_prover/crates/prover/src/witness/components/memory_id_to_big.rs @@ -585,7 +585,7 @@ impl InteractionClaimGenerator { #[cfg(test)] mod tests { -use cairo_air::cairo_interaction_elements::CairoInteractionElements; + use cairo_air::cairo_interaction_elements::CairoInteractionElements; use cairo_air::components::memory_id_to_big::{self, SmallEval}; use cairo_air::PreProcessedTraceVariant; use itertools::Itertools; diff --git a/stwo_cairo_prover/crates/prover/src/witness/mod.rs b/stwo_cairo_prover/crates/prover/src/witness/mod.rs index 303674e361..1869af1a7b 100644 --- a/stwo_cairo_prover/crates/prover/src/witness/mod.rs +++ b/stwo_cairo_prover/crates/prover/src/witness/mod.rs @@ -3,7 +3,6 @@ pub mod builtins; pub mod cairo; pub mod components; pub mod fast_deduction; -pub mod opcodes; pub mod prelude; pub mod preprocessed_trace; pub mod range_checks; diff --git a/stwo_cairo_prover/crates/prover/src/witness/opcodes.rs b/stwo_cairo_prover/crates/prover/src/witness/opcodes.rs deleted file mode 100644 index d5d451619b..0000000000 --- a/stwo_cairo_prover/crates/prover/src/witness/opcodes.rs +++ /dev/null @@ -1,872 +0,0 @@ -use cairo_air::cairo_interaction_elements::CairoInteractionElements; -use cairo_air::opcodes_air::{OpcodeClaim, OpcodeInteractionClaim}; -use stwo::prover::backend::simd::SimdBackend; -use stwo_cairo_adapter::opcodes::StateTransitions; - -use super::blake_context::BlakeContextClaimGenerator; -use super::range_checks::RangeChecksClaimGenerator; -use crate::witness::components::{ - add_ap_opcode, add_opcode, add_opcode_small, assert_eq_opcode, assert_eq_opcode_double_deref, - assert_eq_opcode_imm, blake_compress_opcode, call_opcode_abs, call_opcode_rel_imm, - generic_opcode, jnz_opcode_non_taken, jnz_opcode_taken, jump_opcode_abs, - jump_opcode_double_deref, jump_opcode_rel, jump_opcode_rel_imm, memory_address_to_id, - memory_id_to_big, mul_opcode, mul_opcode_small, qm_31_add_mul_opcode, ret_opcode, - verify_bitwise_xor_8, verify_instruction, -}; -use crate::witness::utils::TreeBuilder; - -pub struct OpcodesClaimGenerator { - add: Vec, - add_small: Vec, - add_ap: Vec, - assert_eq: Vec, - assert_eq_imm: Vec, - assert_eq_double_deref: Vec, - blake: Vec, - call: Vec, - call_rel_imm: Vec, - generic: Vec, - jnz: Vec, - jnz_taken: Vec, - jump: Vec, - jump_double_deref: Vec, - jump_rel: Vec, - jump_rel_imm: Vec, - mul: Vec, - mul_small: Vec, - qm31: Vec, - ret: Vec, -} -impl OpcodesClaimGenerator { - pub fn new(input: StateTransitions) -> Self { - // TODO(Ohad): decide split sizes for opcode traces. - let mut add = vec![]; - let mut add_small = vec![]; - let mut add_ap = vec![]; - let mut assert_eq = vec![]; - let mut assert_eq_imm = vec![]; - let mut assert_eq_double_deref = vec![]; - let mut blake = vec![]; - let mut call = vec![]; - let mut call_rel_imm = vec![]; - let mut generic = vec![]; - let mut jnz = vec![]; - let mut jnz_taken = vec![]; - let mut jump = vec![]; - let mut jump_double_deref = vec![]; - let mut jump_rel = vec![]; - let mut jump_rel_imm = vec![]; - let mut mul = vec![]; - let mut mul_small = vec![]; - let mut qm31 = vec![]; - let mut ret = vec![]; - if !input.casm_states_by_opcode.add_opcode.is_empty() { - add.push(add_opcode::ClaimGenerator::new( - input.casm_states_by_opcode.add_opcode, - )); - } - if !input.casm_states_by_opcode.add_opcode_small.is_empty() { - add_small.push(add_opcode_small::ClaimGenerator::new( - input.casm_states_by_opcode.add_opcode_small, - )); - } - if !input.casm_states_by_opcode.add_ap_opcode.is_empty() { - add_ap.push(add_ap_opcode::ClaimGenerator::new( - input.casm_states_by_opcode.add_ap_opcode, - )); - } - if !input.casm_states_by_opcode.assert_eq_opcode.is_empty() { - assert_eq.push(assert_eq_opcode::ClaimGenerator::new( - input.casm_states_by_opcode.assert_eq_opcode, - )); - } - if !input.casm_states_by_opcode.assert_eq_opcode_imm.is_empty() { - assert_eq_imm.push(assert_eq_opcode_imm::ClaimGenerator::new( - input.casm_states_by_opcode.assert_eq_opcode_imm, - )); - } - if !input - .casm_states_by_opcode - .assert_eq_opcode_double_deref - .is_empty() - { - assert_eq_double_deref.push(assert_eq_opcode_double_deref::ClaimGenerator::new( - input.casm_states_by_opcode.assert_eq_opcode_double_deref, - )); - } - if !input.casm_states_by_opcode.blake_compress_opcode.is_empty() { - blake.push(blake_compress_opcode::ClaimGenerator::new( - input.casm_states_by_opcode.blake_compress_opcode, - )); - } - if !input.casm_states_by_opcode.call_opcode_abs.is_empty() { - call.push(call_opcode_abs::ClaimGenerator::new( - input.casm_states_by_opcode.call_opcode_abs, - )); - } - if !input.casm_states_by_opcode.call_opcode_rel_imm.is_empty() { - call_rel_imm.push(call_opcode_rel_imm::ClaimGenerator::new( - input.casm_states_by_opcode.call_opcode_rel_imm, - )); - } - if !input.casm_states_by_opcode.generic_opcode.is_empty() { - generic.push(generic_opcode::ClaimGenerator::new( - input.casm_states_by_opcode.generic_opcode, - )); - } - if !input.casm_states_by_opcode.jnz_opcode_non_taken.is_empty() { - jnz.push(jnz_opcode_non_taken::ClaimGenerator::new( - input.casm_states_by_opcode.jnz_opcode_non_taken, - )); - } - if !input.casm_states_by_opcode.jnz_opcode_taken.is_empty() { - jnz_taken.push(jnz_opcode_taken::ClaimGenerator::new( - input.casm_states_by_opcode.jnz_opcode_taken, - )); - } - if !input.casm_states_by_opcode.jump_opcode_abs.is_empty() { - jump.push(jump_opcode_abs::ClaimGenerator::new( - input.casm_states_by_opcode.jump_opcode_abs, - )); - } - if !input - .casm_states_by_opcode - .jump_opcode_double_deref - .is_empty() - { - jump_double_deref.push(jump_opcode_double_deref::ClaimGenerator::new( - input.casm_states_by_opcode.jump_opcode_double_deref, - )); - } - if !input.casm_states_by_opcode.jump_opcode_rel.is_empty() { - jump_rel.push(jump_opcode_rel::ClaimGenerator::new( - input.casm_states_by_opcode.jump_opcode_rel, - )); - } - if !input.casm_states_by_opcode.jump_opcode_rel_imm.is_empty() { - jump_rel_imm.push(jump_opcode_rel_imm::ClaimGenerator::new( - input.casm_states_by_opcode.jump_opcode_rel_imm, - )); - } - // Handle small mul in big mul component. Temporary until airs are written with Rc_3_6_6. - if !input.casm_states_by_opcode.mul_opcode.is_empty() { - mul.push(mul_opcode::ClaimGenerator::new( - input.casm_states_by_opcode.mul_opcode, - )); - } - if !input.casm_states_by_opcode.mul_opcode_small.is_empty() { - mul_small.push(mul_opcode_small::ClaimGenerator::new( - input.casm_states_by_opcode.mul_opcode_small, - )); - } - if !input.casm_states_by_opcode.qm_31_add_mul_opcode.is_empty() { - qm31.push(qm_31_add_mul_opcode::ClaimGenerator::new( - input.casm_states_by_opcode.qm_31_add_mul_opcode, - )); - } - if !input.casm_states_by_opcode.ret_opcode.is_empty() { - ret.push(ret_opcode::ClaimGenerator::new( - input.casm_states_by_opcode.ret_opcode, - )); - } - Self { - add, - add_small, - add_ap, - assert_eq, - assert_eq_imm, - assert_eq_double_deref, - blake, - call, - call_rel_imm, - generic, - jnz, - jnz_taken, - jump, - jump_double_deref, - jump_rel, - jump_rel_imm, - mul, - mul_small, - qm31, - ret, - } - } - - pub fn write_trace( - self, - tree_builder: &mut impl TreeBuilder, - blake_context_trace_generator: &mut BlakeContextClaimGenerator, - memory_address_to_id_trace_generator: &memory_address_to_id::ClaimGenerator, - memory_id_to_value_trace_generator: &memory_id_to_big::ClaimGenerator, - range_checks_trace_generator: &RangeChecksClaimGenerator, - verify_instruction_trace_generator: &verify_instruction::ClaimGenerator, - verify_bitwise_xor_8_trace_generator: &mut verify_bitwise_xor_8::ClaimGenerator, - ) -> (OpcodeClaim, OpcodesInteractionClaimGenerator) { - let (add_claims, add_interaction_gens) = self - .add - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (add_small_claims, add_small_interaction_gens) = self - .add_small - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (add_ap_claims, add_ap_interaction_gens) = self - .add_ap - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - &range_checks_trace_generator.rc_18_trace_generator, - &range_checks_trace_generator.rc_11_trace_generator, - ) - }) - .unzip(); - let (assert_eq_claims, assert_eq_interaction_gens) = self - .assert_eq - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (assert_eq_imm_claims, assert_eq_imm_interaction_gens) = self - .assert_eq_imm - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (assert_eq_double_deref_claims, assert_eq_double_deref_interaction_gens) = self - .assert_eq_double_deref - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (blake_claims, blake_interaction_gens) = self - .blake - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - &range_checks_trace_generator.rc_7_2_5_trace_generator, - verify_bitwise_xor_8_trace_generator, - &mut blake_context_trace_generator.blake_round, - &mut blake_context_trace_generator.triple_xor_32, - ) - }) - .unzip(); - let (call_claims, call_interaction_gens) = self - .call - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (call_rel_imm_claims, call_rel_imm_interaction_gens) = self - .call_rel_imm - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (generic_opcode_claims, generic_opcode_interaction_gens) = self - .generic - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - &range_checks_trace_generator.rc_9_9_trace_generator, - &range_checks_trace_generator.rc_9_9_b_trace_generator, - &range_checks_trace_generator.rc_9_9_c_trace_generator, - &range_checks_trace_generator.rc_9_9_d_trace_generator, - &range_checks_trace_generator.rc_9_9_e_trace_generator, - &range_checks_trace_generator.rc_9_9_f_trace_generator, - &range_checks_trace_generator.rc_9_9_g_trace_generator, - &range_checks_trace_generator.rc_9_9_h_trace_generator, - &range_checks_trace_generator.rc_20_trace_generator, - &range_checks_trace_generator.rc_20_b_trace_generator, - &range_checks_trace_generator.rc_20_c_trace_generator, - &range_checks_trace_generator.rc_20_d_trace_generator, - &range_checks_trace_generator.rc_20_e_trace_generator, - &range_checks_trace_generator.rc_20_f_trace_generator, - &range_checks_trace_generator.rc_20_g_trace_generator, - &range_checks_trace_generator.rc_20_h_trace_generator, - &range_checks_trace_generator.rc_18_trace_generator, - &range_checks_trace_generator.rc_11_trace_generator, - ) - }) - .unzip(); - let (jnz_claims, jnz_interaction_gens) = self - .jnz - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (jnz_taken_claims, jnz_taken_interaction_gens) = self - .jnz_taken - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (jump_claims, jump_interaction_gens) = self - .jump - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (jump_double_deref_claims, jump_double_deref_interaction_gens) = self - .jump_double_deref - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (jump_rel_claims, jump_rel_interaction_gens) = self - .jump_rel - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (jump_rel_imm_claims, jump_rel_imm_interaction_gens) = self - .jump_rel_imm - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - let (mul_claims, mul_interaction_gens) = self - .mul - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - &range_checks_trace_generator.rc_20_trace_generator, - &range_checks_trace_generator.rc_20_b_trace_generator, - &range_checks_trace_generator.rc_20_c_trace_generator, - &range_checks_trace_generator.rc_20_d_trace_generator, - &range_checks_trace_generator.rc_20_e_trace_generator, - &range_checks_trace_generator.rc_20_f_trace_generator, - &range_checks_trace_generator.rc_20_g_trace_generator, - &range_checks_trace_generator.rc_20_h_trace_generator, - ) - }) - .unzip(); - let (mul_small_claims, mul_small_interaction_gens) = self - .mul_small - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - &range_checks_trace_generator.rc_11_trace_generator, - ) - }) - .unzip(); - let (qm31_claims, qm31_interaction_gens) = self - .qm31 - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - &range_checks_trace_generator.rc_4_4_4_4_trace_generator, - ) - }) - .unzip(); - let (ret_claims, ret_interaction_gens) = self - .ret - .into_iter() - .map(|gen| { - gen.write_trace( - tree_builder, - memory_address_to_id_trace_generator, - memory_id_to_value_trace_generator, - verify_instruction_trace_generator, - ) - }) - .unzip(); - ( - OpcodeClaim { - add: add_claims, - add_small: add_small_claims, - add_ap: add_ap_claims, - assert_eq: assert_eq_claims, - assert_eq_imm: assert_eq_imm_claims, - assert_eq_double_deref: assert_eq_double_deref_claims, - blake: blake_claims, - call: call_claims, - call_rel_imm: call_rel_imm_claims, - generic: generic_opcode_claims, - jnz: jnz_claims, - jnz_taken: jnz_taken_claims, - jump: jump_claims, - jump_double_deref: jump_double_deref_claims, - jump_rel: jump_rel_claims, - jump_rel_imm: jump_rel_imm_claims, - mul: mul_claims, - mul_small: mul_small_claims, - qm31: qm31_claims, - ret: ret_claims, - }, - OpcodesInteractionClaimGenerator { - add: add_interaction_gens, - add_small: add_small_interaction_gens, - add_ap: add_ap_interaction_gens, - assert_eq: assert_eq_interaction_gens, - assert_eq_imm: assert_eq_imm_interaction_gens, - assert_eq_double_deref: assert_eq_double_deref_interaction_gens, - blake: blake_interaction_gens, - call: call_interaction_gens, - call_rel_imm: call_rel_imm_interaction_gens, - generic_opcode_interaction_gens, - jnz: jnz_interaction_gens, - jnz_taken: jnz_taken_interaction_gens, - jump: jump_interaction_gens, - jump_double_deref: jump_double_deref_interaction_gens, - jump_rel: jump_rel_interaction_gens, - jump_rel_imm: jump_rel_imm_interaction_gens, - mul: mul_interaction_gens, - mul_small: mul_small_interaction_gens, - qm31: qm31_interaction_gens, - ret_interaction_gens, - }, - ) - } -} - -pub struct OpcodesInteractionClaimGenerator { - add: Vec, - add_small: Vec, - add_ap: Vec, - assert_eq: Vec, - assert_eq_imm: Vec, - assert_eq_double_deref: Vec, - blake: Vec, - call: Vec, - call_rel_imm: Vec, - generic_opcode_interaction_gens: Vec, - jnz: Vec, - jnz_taken: Vec, - jump: Vec, - jump_double_deref: Vec, - jump_rel: Vec, - jump_rel_imm: Vec, - mul: Vec, - mul_small: Vec, - qm31: Vec, - ret_interaction_gens: Vec, -} -impl OpcodesInteractionClaimGenerator { - pub fn write_interaction_trace( - self, - tree_builder: &mut impl TreeBuilder, - interaction_elements: &CairoInteractionElements, - ) -> OpcodeInteractionClaim { - let add_interaction_claims = self - .add - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let add_small_interaction_claims = self - .add_small - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let add_ap_interaction_claims = self - .add_ap - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.range_checks.rc_18, - &interaction_elements.range_checks.rc_11, - &interaction_elements.opcodes, - ) - }) - .collect(); - let assert_eq_interaction_claims = self - .assert_eq - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.opcodes, - ) - }) - .collect(); - let assert_eq_imm_interaction_claims = self - .assert_eq_imm - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.opcodes, - ) - }) - .collect(); - let assert_eq_double_deref_interaction_claims = self - .assert_eq_double_deref - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let blake_interaction_claims = self - .blake - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.range_checks.rc_7_2_5, - &interaction_elements.verify_bitwise_xor_8, - &interaction_elements.blake_round, - &interaction_elements.triple_xor_32, - &interaction_elements.opcodes, - ) - }) - .collect(); - let call_interaction_claims = self - .call - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let call_rel_imm_interaction_claims = self - .call_rel_imm - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let generic_opcode_interaction_claims = self - .generic_opcode_interaction_gens - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.range_checks.rc_9_9, - &interaction_elements.range_checks.rc_9_9_b, - &interaction_elements.range_checks.rc_9_9_c, - &interaction_elements.range_checks.rc_9_9_d, - &interaction_elements.range_checks.rc_9_9_e, - &interaction_elements.range_checks.rc_9_9_f, - &interaction_elements.range_checks.rc_9_9_g, - &interaction_elements.range_checks.rc_9_9_h, - &interaction_elements.range_checks.rc_20, - &interaction_elements.range_checks.rc_20_b, - &interaction_elements.range_checks.rc_20_c, - &interaction_elements.range_checks.rc_20_d, - &interaction_elements.range_checks.rc_20_e, - &interaction_elements.range_checks.rc_20_f, - &interaction_elements.range_checks.rc_20_g, - &interaction_elements.range_checks.rc_20_h, - &interaction_elements.range_checks.rc_18, - &interaction_elements.range_checks.rc_11, - &interaction_elements.opcodes, - ) - }) - .collect(); - let jnz_interaction_claims = self - .jnz - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let jnz_taken_interaction_claims = self - .jnz_taken - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let jump_interaction_claims = self - .jump - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let jump_double_deref_interaction_claims = self - .jump_double_deref - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let jump_rel_interaction_claims = self - .jump_rel - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let jump_rel_imm_interaction_claims = self - .jump_rel_imm - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - let mul_interaction_claims = self - .mul - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.range_checks.rc_20, - &interaction_elements.range_checks.rc_20_b, - &interaction_elements.range_checks.rc_20_c, - &interaction_elements.range_checks.rc_20_d, - &interaction_elements.range_checks.rc_20_e, - &interaction_elements.range_checks.rc_20_f, - &interaction_elements.range_checks.rc_20_g, - &interaction_elements.range_checks.rc_20_h, - &interaction_elements.opcodes, - ) - }) - .collect(); - let mul_small_interaction_claims = self - .mul_small - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.range_checks.rc_11, - &interaction_elements.opcodes, - ) - }) - .collect(); - let qm31_interaction_claims = self - .qm31 - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.range_checks.rc_4_4_4_4, - &interaction_elements.opcodes, - ) - }) - .collect(); - let ret_interaction_claims = self - .ret_interaction_gens - .into_iter() - .map(|gen| { - gen.write_interaction_trace( - tree_builder, - &interaction_elements.verify_instruction, - &interaction_elements.memory_address_to_id, - &interaction_elements.memory_id_to_value, - &interaction_elements.opcodes, - ) - }) - .collect(); - OpcodeInteractionClaim { - add: add_interaction_claims, - add_small: add_small_interaction_claims, - add_ap: add_ap_interaction_claims, - assert_eq: assert_eq_interaction_claims, - assert_eq_imm: assert_eq_imm_interaction_claims, - assert_eq_double_deref: assert_eq_double_deref_interaction_claims, - blake: blake_interaction_claims, - call: call_interaction_claims, - call_rel_imm: call_rel_imm_interaction_claims, - generic: generic_opcode_interaction_claims, - jnz: jnz_interaction_claims, - jnz_taken: jnz_taken_interaction_claims, - jump: jump_interaction_claims, - jump_double_deref: jump_double_deref_interaction_claims, - jump_rel: jump_rel_interaction_claims, - jump_rel_imm: jump_rel_imm_interaction_claims, - mul: mul_interaction_claims, - mul_small: mul_small_interaction_claims, - qm31: qm31_interaction_claims, - ret: ret_interaction_claims, - } - } -}