chore: rebase and remove conflicts

air/src/air/aux.rs

@@ -116,7 +116,7 @@ impl<E: FieldElement> GkrData<E> {
                 .fold(E::ZERO, |acc, (a, b)| acc + *a * *b)
     }
 
-    pub fn compute_batched_query_<F>(&self, query: &[F]) -> E
+    pub fn compute_batched_query<F>(&self, query: &[F]) -> E
     where
         F: FieldElement<BaseField = E::BaseField>,
         E: ExtensionOf<F>,

air/src/air/context.rs

@@ -8,9 +8,8 @@ use core::cmp;
 
 use math::StarkField;
 
-use crate::{air::TransitionConstraintDegree, ProofOptions, TraceInfo};
-
 use super::LAGRANGE_KERNEL_OFFSET;
+use crate::{air::TransitionConstraintDegree, ProofOptions, TraceInfo};
 
 // AIR CONTEXT
 // ================================================================================================
@@ -255,11 +254,6 @@ impl<B: StarkField> AirContext<B> {
         self.logup_gkr
     }
 
-    /// Returns true if the auxiliary trace segment contains a Lagrange kernel column
-    pub fn is_with_logup_gkr(&self) -> bool {
-        self.logup_gkr
-    }
-
     /// Returns the total number of assertions defined for a computation, excluding the Lagrange
     /// kernel assertion, which is managed separately.
     ///

prover/src/constraints/evaluator/logup_gkr.rs

@@ -6,7 +6,9 @@
 use alloc::vec::Vec;
 
 use air::{
-    Air, EvaluationFrame, GkrData, LagrangeConstraintsCompositionCoefficients, LagrangeKernelConstraints, LagrangeKernelEvaluationFrame, LogUpGkrEvaluator, LAGRANGE_KERNEL_OFFSET, S_COLUMN_OFFSET
+    Air, EvaluationFrame, GkrData, LagrangeConstraintsCompositionCoefficients,
+    LagrangeKernelConstraints, LagrangeKernelEvaluationFrame, LogUpGkrEvaluator,
+    LAGRANGE_KERNEL_OFFSET, S_COLUMN_OFFSET,
 };
 use math::{batch_inversion, FieldElement};
 
@@ -79,6 +81,7 @@ where
 
         let c = self.gkr_data.compute_batched_claim();
         let mean = c / E::from(E::BaseField::from(trace.trace_info().length() as u32));
+        let mut query = vec![E::BaseField::ZERO; evaluator.get_oracles().len()];
 
         for step in 0..domain.ce_domain_size() {
             // compute Lagrange kernel frame
@@ -129,8 +132,8 @@ where
                 let s_cur = aux_frame.current()[s_col_idx];
                 let s_nxt = aux_frame.next()[s_col_idx];
 
-                let query = evaluator.build_query(&main_frame, &[]);
-                let batched_query = self.gkr_data.compute_batched_query_(&query);
+                evaluator.build_query(&main_frame, &[], &mut query);
+                let batched_query = self.gkr_data.compute_batched_query(&query);
 
                 let rhs = s_cur - mean + batched_query * l_cur;
                 let lhs = s_nxt;

prover/src/logup_gkr/prover.rs

@@ -76,8 +76,13 @@ pub fn prove_gkr<E: FieldElement>(
     let mut main_trace_mls =
         build_mls_from_main_trace_segment(evaluator.get_oracles(), main_trace.main_segment())?;
 
-    let final_layer_proof =
-        prove_input_layer(evaluator, logup_randomness, &mut main_trace_mls, gkr_claim, public_coin)?;
+    let final_layer_proof = prove_input_layer(
+        evaluator,
+        logup_randomness,
+        &mut main_trace_mls,
+        gkr_claim,
+        public_coin,
+    )?;
 
     // include the circuit output as part of the final proof
     let CircuitLayerPolys { numerators, denominators } = circuit.output_layer().clone();
@@ -97,7 +102,7 @@ fn prove_input_layer<
 >(
     evaluator: &impl LogUpGkrEvaluator<BaseField = E::BaseField>,
     log_up_randomness: Vec<E>,
-    multi_linear_ext_polys: &mut[MultiLinearPoly<E>],
+    multi_linear_ext_polys: &mut [MultiLinearPoly<E>],
     claim: GkrClaim<E>,
     transcript: &mut C,
 ) -> Result<FinalLayerProof<E>, GkrProverError> {
@@ -236,10 +241,7 @@ fn prove_intermediate_layers<
 
     Ok((
         BeforeFinalLayerProof { proof: layer_proofs },
-        GkrClaim {
-            evaluation_point,
-            claimed_evaluation,
-        },
+        GkrClaim { evaluation_point, claimed_evaluation },
     ))
 }
 

verifier/src/evaluator.rs

@@ -131,8 +131,10 @@ pub fn evaluate_constraints<A: Air, E: FieldElement<BaseField = A::BaseField>>(
         let mean = batched_claim
             .mul_base(E::BaseField::ONE / E::BaseField::from(air.trace_length() as u32));
 
-        let query = air.get_logup_gkr_evaluator::<E>().build_query(main_trace_frame, &[]);
-        let batched_claim_at_query = gkr_data.compute_batched_query_::<E>(&query);
+        let mut query = vec![E::ZERO; air.get_logup_gkr_evaluator::<E>().get_oracles().len()];
+        air.get_logup_gkr_evaluator::<E>()
+            .build_query(main_trace_frame, &[], &mut query);
+        let batched_claim_at_query = gkr_data.compute_batched_query::<E>(&query);
         let rhs = s_cur - mean + batched_claim_at_query * l_cur;
         let lhs = s_nxt;