fix(new-execution): warn if max_constraint_degree differ (#1979)

- emit a warning if `max_constraint_degree` don't matching between
`VmConfig` and `StarkFriConfig`

Author: shuklaayush

benchmarks/prove/src/bin/verify_fibair.rs

@@ -54,6 +54,7 @@ fn main() -> Result<()> {
             app_fri_params.max_constraint_degree().min(7),
         );
         app_vm_config.system.profiling = args.profiling;
+        app_vm_config.system.max_constraint_degree = (1 << app_log_blowup) + 1;
 
         let compiler_options = CompilerOptions::default();
         let app_config = AppConfig {

benchmarks/prove/src/util.rs

@@ -88,6 +88,7 @@ impl BenchmarkCli {
         let leaf_log_blowup = self.leaf_log_blowup.unwrap_or(DEFAULT_LEAF_LOG_BLOWUP);
 
         app_vm_config.as_mut().profiling = self.profiling;
+        app_vm_config.as_mut().max_constraint_degree = (1 << app_log_blowup) + 1;
         if let Some(max_height) = self.max_segment_length {
             app_vm_config.as_mut().segmentation_limits.max_trace_height = max_height;
         }

crates/sdk/src/keygen/mod.rs

@@ -49,6 +49,7 @@ use crate::{
         perm::AirIdPermutation,
     },
     prover::vm::types::VmProvingKey,
+    util::check_max_constraint_degrees,
     RootSC, SC,
 };
 
@@ -126,6 +127,10 @@ where
                 vm_pk.max_constraint_degree
                     <= config.app_fri_params.fri_params.max_constraint_degree()
             );
+            check_max_constraint_degrees(
+                config.app_vm_config.as_ref(),
+                &config.app_fri_params.fri_params,
+            );
             VmProvingKey {
                 fri_params: config.app_fri_params.fri_params,
                 vm_config: config.app_vm_config.clone(),
@@ -306,6 +311,7 @@ impl AggProvingKey {
                 leaf_vm_config.clone(),
             )?;
             assert!(vm_pk.max_constraint_degree <= config.leaf_fri_params.max_constraint_degree());
+            check_max_constraint_degrees(&leaf_vm_config.system, &config.leaf_fri_params);
             Arc::new(VmProvingKey {
                 fri_params: config.leaf_fri_params,
                 vm_config: leaf_vm_config,
@@ -325,6 +331,7 @@ impl AggProvingKey {
             NativeCpuBuilder,
             internal_vm_config.clone(),
         )?;
+        check_max_constraint_degrees(&internal_vm_config.system, &config.internal_fri_params);
         assert!(vm_pk.max_constraint_degree <= config.internal_fri_params.max_constraint_degree());
         let internal_vm_pk = Arc::new(VmProvingKey {
             fri_params: config.internal_fri_params,

crates/sdk/src/lib.rs

@@ -73,6 +73,7 @@ pub mod fs;
 pub mod keygen;
 pub mod prover;
 pub mod types;
+pub mod util;
 
 mod error;
 mod stdin;

crates/sdk/src/prover/agg.rs

@@ -16,7 +16,8 @@ use openvm_stark_sdk::{engine::StarkFriEngine, openvm_stark_backend::proof::Proo
 use tracing::{info_span, instrument};
 
 use crate::{
-    config::AggregationTreeConfig, keygen::AggProvingKey, prover::vm::new_local_prover, F, SC,
+    config::AggregationTreeConfig, keygen::AggProvingKey, prover::vm::new_local_prover,
+    util::check_max_constraint_degrees, F, SC,
 };
 #[cfg(feature = "evm-prove")]
 use crate::{prover::RootVerifierLocalProver, RootSC};
@@ -124,6 +125,10 @@ where
         &mut self,
         app_proofs: &ContinuationVmProof<SC>,
     ) -> Result<Vec<Proof<SC>>, VirtualMachineError> {
+        check_max_constraint_degrees(
+            self.leaf_prover.vm.config().as_ref(),
+            &self.leaf_prover.vm.engine.fri_params(),
+        );
         self.leaf_controller
             .generate_proof(&mut self.leaf_prover, app_proofs)
     }
@@ -146,6 +151,11 @@ where
         leaf_proofs: Vec<Proof<SC>>,
         public_values: Vec<F>,
     ) -> Result<VmStarkProof<SC>, VirtualMachineError> {
+        check_max_constraint_degrees(
+            self.internal_prover.vm.config().as_ref(),
+            &self.internal_prover.vm.engine.fri_params(),
+        );
+
         let mut internal_node_idx = -1;
         let mut internal_node_height = 0;
         let mut proofs = leaf_proofs;
@@ -258,6 +268,10 @@ where
         &mut self,
         root_input: RootVmVerifierInput<SC>,
     ) -> Result<Proof<RootSC>, VirtualMachineError> {
+        check_max_constraint_degrees(
+            self.root_prover.vm_config().as_ref(),
+            self.root_prover.fri_params(),
+        );
         let input = root_input.write();
         #[cfg(feature = "metrics")]
         metrics::counter!("fri.log_blowup")

crates/sdk/src/prover/app.rs

@@ -27,6 +27,7 @@ use crate::{
     commit::{AppExecutionCommit, CommitBytes},
     keygen::AppVerifyingKey,
     prover::vm::{new_local_prover, types::VmProvingKey},
+    util::check_max_constraint_degrees,
     StdIn, F, SC,
 };
 
@@ -133,6 +134,10 @@ where
             self.vm_config().as_ref().continuation_enabled,
             "Use generate_app_proof_without_continuations instead."
         );
+        check_max_constraint_degrees(
+            self.vm_config().as_ref(),
+            &self.instance.vm.engine.fri_params(),
+        );
         let proofs = info_span!(
             "app proof",
             group = self

crates/sdk/src/util.rs

@@ -0,0 +1,12 @@
+use openvm_circuit::arch::SystemConfig;
+use openvm_stark_sdk::config::FriParameters;
+
+pub fn check_max_constraint_degrees(config: &SystemConfig, fri_params: &FriParameters) {
+    if config.max_constraint_degree != fri_params.max_constraint_degree() {
+        tracing::warn!(
+            "config.max_constraint_degree ({}) != fri_params.max_constraint_degree() ({})",
+            config.max_constraint_degree,
+            fri_params.max_constraint_degree()
+        );
+    }
+}