fix(sumcheck): scale polynomial evals for phase1 gap rounds in RAF and output check (#1385)

When phase1_num_rounds < log_T, the input_claim for RafEvaluation and
OutputCheck sumchecks is pre-scaled by 2^(phase3_cycle_rounds) to
pre-compensate for the gap-round halvings. However, the raw polynomial
evaluations computed from the witness data sum to the unscaled claim.
This mismatch causes UniPoly reconstruction to produce an incorrect
polynomial, failing the verifier's poly(0) + poly(1) == previous_claim
check.

Scale the raw evaluations by 2^(phase3_cycle_rounds) before polynomial
reconstruction so they are consistent with the pre-scaled previous_claim.

Made-with: Cursor

Author: quangvdao

jolt-core/src/zkvm/ram/output_check.rs

@@ -308,7 +308,20 @@ impl<F: JoltField, T: Transcript> SumcheckInstanceProver<F, T> for OutputSumchec
             [c0, e]
         });
 
-        eq_r_address.gruen_poly_deg_3(q_constant, q_quadratic, previous_claim)
+        // When phase1_num_rounds < log_T, the input_claim is pre-scaled by
+        // 2^(phase3_cycle_rounds) to compensate for the gap-round halvings that follow.
+        // The raw q_constant and q_quadratic sum to the unscaled claim, so we must
+        // scale them by the same factor to satisfy poly(0) + poly(1) == previous_claim.
+        let gap = self.params.phase3_cycle_rounds();
+        if gap > 0 {
+            eq_r_address.gruen_poly_deg_3(
+                q_constant.mul_pow_2(gap),
+                q_quadratic.mul_pow_2(gap),
+                previous_claim,
+            )
+        } else {
+            eq_r_address.gruen_poly_deg_3(q_constant, q_quadratic, previous_claim)
+        }
     }
 
     #[tracing::instrument(skip_all, name = "OutputSumcheckProver::ingest_challenge")]

jolt-core/src/zkvm/ram/raf_evaluation.rs

@@ -306,7 +306,17 @@ impl<F: JoltField, T: Transcript> SumcheckInstanceProver<F, T> for RafEvaluation
             )
             .map(F::reduce_product_accum);
 
-        UniPoly::from_evals_and_hint(previous_claim, &evals)
+        // When phase1_num_rounds < log_T, the input_claim is pre-scaled by
+        // 2^(phase3_cycle_rounds) to compensate for the gap-round halvings that follow.
+        // The raw polynomial evals sum to the unscaled claim, so we must scale them
+        // by the same factor to satisfy poly(0) + poly(1) == previous_claim.
+        let gap = self.params.phase3_cycle_rounds();
+        if gap > 0 {
+            let scaled: Vec<F> = evals.iter().map(|e| e.mul_pow_2(gap)).collect();
+            UniPoly::from_evals_and_hint(previous_claim, &scaled)
+        } else {
+            UniPoly::from_evals_and_hint(previous_claim, &evals)
+        }
     }
 
     #[tracing::instrument(skip_all, name = "RamRafEvaluationSumcheckProver::ingest_challenge")]