Remove log_sizes field from CircuitClaim

crates/cairo_verifier/src/statement.rs

@@ -348,6 +348,7 @@ impl<Value: IValue> Statement<Value> for CairoStatement<Value> {
         let flat_program = pack_into_qm31s(program.iter().flatten().cloned());
         let program_hash = IValue::blake(&flat_program, flat_program.len() * 16);
         vec![
+            self.component_log_sizes.get_packed().to_vec(),
             vec![program_len],
             packed_public_data.get_packed().to_vec(),
             vec![output_hash.0, output_hash.1],

crates/circuit_prover/src/circuit_air/circuit_components.rs

@@ -3,10 +3,8 @@ use crate::circuit_air::components::{
     range_check_15, range_check_16, triple_xor_32, verify_bitwise_xor_4, verify_bitwise_xor_7,
     verify_bitwise_xor_8, verify_bitwise_xor_9, verify_bitwise_xor_12,
 };
-use circuit_verifier::circuit_claim::{
-    CircuitClaim, CircuitInteractionClaim, CircuitInteractionElements,
-};
-use circuit_verifier::circuit_components::ComponentList;
+use circuit_verifier::circuit_claim::{CircuitInteractionClaim, CircuitInteractionElements};
+use circuit_verifier::circuit_components::{ComponentList, N_COMPONENTS};
 use stwo::core::air::Component;
 use stwo_constraint_framework::TraceLocationAllocator;
 use stwo_constraint_framework::preprocessed_columns::PreProcessedColumnId;
@@ -31,9 +29,9 @@ pub struct CircuitComponents {
 }
 impl CircuitComponents {
     pub fn new(
-        circuit_claim: &CircuitClaim,
         interaction_elements: &CircuitInteractionElements,
         interaction_claim: &CircuitInteractionClaim,
+        component_log_sizes: &[u32; N_COMPONENTS],
         // Describes the structure of the preprocessed trace. Sensitive to order.
         preprocessed_column_ids: &[PreProcessedColumnId],
     ) -> Self {
@@ -43,15 +41,15 @@ impl CircuitComponents {
         let eq_component = eq::Component::new(
             tree_span_provider,
             eq::Eval {
-                log_size: circuit_claim.log_sizes[ComponentList::Eq as usize],
+                log_size: component_log_sizes[ComponentList::Eq as usize],
                 common_lookup_elements: interaction_elements.common_lookup_elements.clone(),
             },
             interaction_claim.claimed_sums[ComponentList::Eq as usize],
         );
         let qm31_ops_component = qm31_ops::Component::new(
             tree_span_provider,
             qm31_ops::Eval {
-                log_size: circuit_claim.log_sizes[ComponentList::Qm31Ops as usize],
+                log_size: component_log_sizes[ComponentList::Qm31Ops as usize],
                 common_lookup_elements: interaction_elements.common_lookup_elements.clone(),
             },
             interaction_claim.claimed_sums[ComponentList::Qm31Ops as usize],
@@ -60,7 +58,7 @@ impl CircuitComponents {
             tree_span_provider,
             blake_gate::Eval {
                 claim: blake_gate::Claim {
-                    log_size: circuit_claim.log_sizes[ComponentList::BlakeGate as usize],
+                    log_size: component_log_sizes[ComponentList::BlakeGate as usize],
                 },
                 common_lookup_elements: interaction_elements.common_lookup_elements.clone(),
             },
@@ -70,7 +68,7 @@ impl CircuitComponents {
             tree_span_provider,
             blake_round::Eval {
                 claim: blake_round::Claim {
-                    log_size: circuit_claim.log_sizes[ComponentList::BlakeRound as usize],
+                    log_size: component_log_sizes[ComponentList::BlakeRound as usize],
                 },
                 common_lookup_elements: interaction_elements.common_lookup_elements.clone(),
             },
@@ -88,7 +86,7 @@ impl CircuitComponents {
             tree_span_provider,
             blake_g::Eval {
                 claim: blake_g::Claim {
-                    log_size: circuit_claim.log_sizes[ComponentList::BlakeG as usize],
+                    log_size: component_log_sizes[ComponentList::BlakeG as usize],
                 },
                 common_lookup_elements: interaction_elements.common_lookup_elements.clone(),
             },
@@ -98,7 +96,7 @@ impl CircuitComponents {
             tree_span_provider,
             blake_output::Eval {
                 claim: blake_output::Claim {
-                    log_size: circuit_claim.log_sizes[ComponentList::BlakeOutput as usize],
+                    log_size: component_log_sizes[ComponentList::BlakeOutput as usize],
                 },
                 common_lookup_elements: interaction_elements.common_lookup_elements.clone(),
             },
@@ -108,7 +106,7 @@ impl CircuitComponents {
             tree_span_provider,
             triple_xor_32::Eval {
                 claim: triple_xor_32::Claim {
-                    log_size: circuit_claim.log_sizes[ComponentList::TripleXor32 as usize],
+                    log_size: component_log_sizes[ComponentList::TripleXor32 as usize],
                 },
                 common_lookup_elements: interaction_elements.common_lookup_elements.clone(),
             },
@@ -118,7 +116,7 @@ impl CircuitComponents {
             tree_span_provider,
             m_31_to_u_32::Eval {
                 claim: m_31_to_u_32::Claim {
-                    log_size: circuit_claim.log_sizes[ComponentList::M31ToU32 as usize],
+                    log_size: component_log_sizes[ComponentList::M31ToU32 as usize],
                 },
                 common_lookup_elements: interaction_elements.common_lookup_elements.clone(),
             },

crates/circuit_prover/src/prover.rs

@@ -8,7 +8,7 @@ use circuit_common::preprocessed::PreprocessedCircuit;
 use circuit_verifier::circuit_claim::{
     CircuitClaim, CircuitInteractionClaim, CircuitInteractionElements, lookup_sum,
 };
-use circuit_verifier::statement::{INTERACTION_POW_BITS, component_log_sizes};
+use circuit_verifier::statement::INTERACTION_POW_BITS;
 use circuit_verifier::verify::CircuitPublicData;
 use circuits_stark_verifier::proof::Proof;
 use circuits_stark_verifier::proof::ProofConfig;
@@ -187,7 +187,7 @@ where
 
     // Base trace.
     let mut tree_builder = commitment_scheme.tree_builder();
-    let (claim, interaction_generator) = write_trace(
+    let (claim, component_log_sizes, interaction_generator) = write_trace(
         values,
         preprocessed_trace.clone(),
         output_addresses,
@@ -196,12 +196,12 @@ where
         twiddles,
     );
 
-    let expected_log_sizes = component_log_sizes(
+    let expected_log_sizes = circuit_verifier::statement::component_log_sizes(
         *n_blake_compress,
         &preprocessed_trace.ids(),
         &preprocessed_trace.log_sizes(),
     );
-    assert_eq!(claim.log_sizes, expected_log_sizes);
+    assert_eq!(component_log_sizes, expected_log_sizes);
     claim.mix_into(channel);
     tree_builder.commit(channel);
 
@@ -213,7 +213,7 @@ where
     // Interaction trace.
     let mut tree_builder = commitment_scheme.tree_builder();
     let interaction_claim = write_interaction_trace(
-        &claim,
+        &component_log_sizes,
         interaction_generator,
         &mut tree_builder,
         &interaction_elements,
@@ -236,9 +236,9 @@ where
     tree_builder.commit(channel);
     // Component provers.
     let circuit_components = CircuitComponents::new(
-        &claim,
         &interaction_elements,
         &interaction_claim,
+        &component_log_sizes,
         &preprocessed_trace.ids(),
     );
     let components = to_component_provers(&circuit_components);

crates/circuit_prover/src/witness/trace.rs

@@ -22,6 +22,7 @@ use circuit_common::preprocessed::PreProcessedTrace;
 use circuit_verifier::circuit_claim::CircuitClaim;
 use circuit_verifier::circuit_claim::CircuitInteractionClaim;
 use circuit_verifier::circuit_claim::CircuitInteractionElements;
+use circuit_verifier::circuit_components::N_COMPONENTS;
 use itertools::Itertools;
 use num_traits::Zero;
 use rayon::scope;
@@ -44,7 +45,7 @@ pub fn write_trace<MC: MerkleChannel>(
     tree_builder: &mut TreeBuilder<'_, '_, SimdBackend, MC>,
     trace_generator: &TraceGenerator,
     twiddles: &TwiddleTree<SimdBackend>,
-) -> (CircuitClaim, CircuitInteractionClaimGenerator)
+) -> (CircuitClaim, [u32; N_COMPONENTS], CircuitInteractionClaimGenerator)
 where
     SimdBackend: BackendForChannel<MC>,
 {
@@ -407,7 +408,8 @@ where
     ];
 
     (
-        CircuitClaim { log_sizes, output_values },
+        CircuitClaim { output_values },
+        log_sizes,
         CircuitInteractionClaimGenerator {
             eq_lookup_data,
             qm31_ops_lookup_data,
@@ -449,7 +451,7 @@ pub struct CircuitInteractionClaimGenerator {
 }
 
 pub fn write_interaction_trace<MC: MerkleChannel>(
-    circuit_claim: &CircuitClaim,
+    component_log_sizes: &[u32; N_COMPONENTS],
     circuit_interaction_claim_generator: CircuitInteractionClaimGenerator,
     tree_builder: &mut TreeBuilder<'_, '_, SimdBackend, MC>,
     interaction_elements: &CircuitInteractionElements,
@@ -458,8 +460,7 @@ pub fn write_interaction_trace<MC: MerkleChannel>(
 where
     SimdBackend: BackendForChannel<MC>,
 {
-    let CircuitClaim { log_sizes, output_values: _ } = circuit_claim;
-    let mut component_log_size_iter = log_sizes.iter();
+    let mut component_log_size_iter = component_log_sizes.iter();
 
     // Extract log sizes before parallel section.
     let eq_log_size = *component_log_size_iter.next().unwrap();

crates/circuit_verifier/src/circuit_claim.rs

@@ -2,7 +2,7 @@ use crate::blake2s_consts::blake2s_initial_state;
 use crate::circuit_components::N_COMPONENTS;
 use crate::relations::{BLAKE_STATE_RELATION_ID, CommonLookupElements, GATE_RELATION_ID};
 use circuits::ivalue::qm31_from_u32s;
-use circuits_stark_verifier::proof_from_stark_proof::{pack_component_log_sizes, pack_enable_bits};
+use circuits_stark_verifier::proof_from_stark_proof::pack_enable_bits;
 use itertools::zip_eq;
 use num_traits::Zero;
 use stwo::core::channel::Channel;
@@ -16,21 +16,17 @@ pub type ClaimedSum = QM31;
 
 #[derive(Debug, PartialEq)]
 pub struct CircuitClaim {
-    // TODO(ilya): Remove `log_sizes` they are fixed given a CircuitConfig.
-    pub log_sizes: [ComponentLogSize; N_COMPONENTS],
     pub output_values: Vec<QM31>,
 }
 impl CircuitClaim {
     pub fn mix_into(&self, channel: &mut impl Channel) {
-        let Self { log_sizes, output_values } = self;
+        let Self { output_values } = self;
 
         // mix the number of components.
-        let n_components = log_sizes.len();
-        channel.mix_felts(&[qm31_from_u32s(n_components as u32, 0, 0, 0)]);
+        channel.mix_felts(&[qm31_from_u32s(N_COMPONENTS.try_into().unwrap(), 0, 0, 0)]);
 
         // mix the enable bits into the channel.
         channel.mix_felts(&pack_enable_bits(&[true; N_COMPONENTS]));
-        channel.mix_felts(&pack_component_log_sizes(log_sizes));
         // mix the output values into the channel.
         channel.mix_felts(output_values);
     }

crates/stark_verifier/src/verify.rs

@@ -91,7 +91,6 @@ pub fn verify<Value: IValue>(
         pack_enable_bits(enable_bits).into_iter().map(|qm31| context.constant(qm31)).collect_vec();
     channel.mix_qm31s(context, packed_enable_bits);
 
-    channel.mix_qm31s(context, component_log_sizes.get_packed().iter().cloned());
     for claim_to_mix in statement.claims_to_mix(context) {
         channel.mix_qm31s(context, claim_to_mix.iter().cloned());
     }

crates/stark_verifier_examples/src/simple_air.rs

@@ -1,7 +1,5 @@
 use circuits::ivalue::qm31_from_u32s;
-use circuits_stark_verifier::proof_from_stark_proof::{
-    pack_component_log_sizes, pack_enable_bits, pack_public_claim,
-};
+use circuits_stark_verifier::proof_from_stark_proof::{pack_enable_bits, pack_public_claim};
 
 use itertools::{Itertools, zip_eq};
 use num_traits::One;
@@ -32,7 +30,7 @@ use stwo_constraint_framework::{
     TraceLocationAllocator, relation,
 };
 
-use crate::simple_statement::{COMPONENT_ENABLE_BITS, COMPONENT_LOG_SIZES};
+use crate::simple_statement::COMPONENT_ENABLE_BITS;
 
 pub const INTERACTION_POW_BITS: u32 = 8;
 
@@ -244,10 +242,6 @@ pub fn create_proof_with_fold_step(
     let packed_enable_bits = pack_enable_bits(&COMPONENT_ENABLE_BITS);
     prover_channel.mix_felts(&packed_enable_bits);
 
-    // Mix the component log sizes into the channel.
-    let packed_component_log_sizes = pack_component_log_sizes(&COMPONENT_LOG_SIZES);
-    prover_channel.mix_felts(&packed_component_log_sizes);
-
     // Mix the public claim into the channel.
     // Public claim is empty.
     let public_claim = pack_public_claim(&[]);

crates/stark_verifier_examples/src/simple_air_test.rs

@@ -5,15 +5,14 @@ use stwo::core::vcs_lifted::blake2_merkle::Blake2sM31MerkleChannel;
 use stwo::core::verifier::verify;
 
 use crate::simple_air::{INTERACTION_POW_BITS, LOG_SIZE_LONG, LOG_SIZE_SHORT, create_proof};
-use crate::simple_statement::{COMPONENT_ENABLE_BITS, COMPONENT_LOG_SIZES};
+use crate::simple_statement::COMPONENT_ENABLE_BITS;
 use circuits::ivalue::qm31_from_u32s;
-use circuits_stark_verifier::proof_from_stark_proof::{pack_component_log_sizes, pack_enable_bits};
+use circuits_stark_verifier::proof_from_stark_proof::pack_enable_bits;
 
 #[test]
 fn verify_simple_proof() {
     let (components, claimed_sums, config, proof, interaction_pow_nonce, channel_salt) =
         create_proof();
-    let packed_component_log_sizes = pack_component_log_sizes(&COMPONENT_LOG_SIZES);
 
     // Verify.
     let verifier_channel = &mut Blake2sM31Channel::default();
@@ -33,7 +32,6 @@ fn verify_simple_proof() {
 
     verifier_channel.mix_felts(&[qm31_from_u32s(COMPONENT_ENABLE_BITS.len() as u32, 0, 0, 0)]);
     verifier_channel.mix_felts(&pack_enable_bits(&COMPONENT_ENABLE_BITS));
-    verifier_channel.mix_felts(&packed_component_log_sizes);
     verifier_channel.mix_felts(&[]);
     commitment_scheme.commit(proof.proof.commitments[1], &sizes[1], verifier_channel);
     verifier_channel.verify_pow_nonce(INTERACTION_POW_BITS, interaction_pow_nonce);