refactor: drop the lambdavm cycle cap and resource test

No other prover caps execution cycles or tests the unsupported resource error.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: codygunton

crates/prover/lambdavm/src/error.rs

@@ -18,9 +18,6 @@ pub enum Error {
     #[error("LambdaVM execution failed: {0}")]
     Execute(#[source] ExecutorError),
 
-    #[error("LambdaVM execution exceeded {0} cycles")]
-    CycleLimitExceeded(u64),
-
     #[error("LambdaVM cost estimation failed: {0}")]
     EstimateCost(#[source] lambda_vm_prover::Error),
 

crates/prover/lambdavm/src/executor.rs

@@ -10,13 +10,6 @@ use lambda_vm_executor::{elf::Elf, vm::execution::Executor as VmExecutor};
 
 use crate::error::Error;
 
-/// Execution stops with an error beyond this many cycles, so a guest that never
-/// halts cannot hang the caller.
-pub(crate) const MAX_CYCLES: u64 = 1 << 32;
-
-/// Cycles run between two checks of [`MAX_CYCLES`].
-const CHUNK_CYCLES: usize = 1 << 20;
-
 /// An execution instance of a loaded program.
 pub(crate) struct Executor {
     program: Arc<Elf>,
@@ -48,14 +41,8 @@ pub(crate) fn run(program: &Elf, stdin: &[u8]) -> Result<(VmExecutor, u64), Erro
     let mut executor = VmExecutor::new(program, stdin.to_vec()).map_err(Error::Execute)?;
 
     let mut cycles = 0;
-    while let Some(logs) = executor
-        .resume_with_limit(CHUNK_CYCLES)
-        .map_err(Error::Execute)?
-    {
+    while let Some(logs) = executor.resume().map_err(Error::Execute)? {
         cycles += logs.len() as u64;
-        if cycles > MAX_CYCLES {
-            return Err(Error::CycleLimitExceeded(MAX_CYCLES));
-        }
     }
 
     Ok((executor, cycles))

crates/prover/lambdavm/src/lib.rs

@@ -31,9 +31,9 @@
 //! | `main_elements` | Field elements of the main traces of all tables              |
 //! | `aux_elements`  | Field elements of the auxiliary (LogUp) traces of all tables |
 //!
-//! Execution fails after 2^32 cycles. It runs in chunks, so its memory use does
-//! not grow with the cycle count, but the element counts and proving keep one
-//! log per cycle in memory, because `lambda-vm-prover` executes at once.
+//! Execution runs in chunks, so its memory use does not grow with the cycle
+//! count, but the element counts and proving keep one log per cycle in memory,
+//! because `lambda-vm-prover` executes at once.
 //!
 //! `peak_heap_bytes` spans from the `_end` symbol up to the highest non-zero
 //! byte below the top of the guest heap at `0xC0000000`, or is `None` when the

crates/prover/lambdavm/src/prover.rs

@@ -119,7 +119,7 @@ mod tests {
 
     use ere_compiler_core::{Compiler, Elf};
     use ere_compiler_lambdavm::{LambdaVMRustRv64ima, LambdaVMRustRv64imaCustomized};
-    use ere_prover_core::{CommonError, Input, ProverResource, codec::Encode, zkVMProver};
+    use ere_prover_core::{Input, ProverResource, codec::Encode, zkVMProver};
     use ere_util_test::{
         codec::BincodeLegacy,
         host::{
@@ -129,7 +129,7 @@ mod tests {
         program::basic::BasicProgram,
     };
 
-    use crate::{error::Error, prover::LambdaVMProver};
+    use crate::prover::LambdaVMProver;
 
     fn basic_elf() -> Elf {
         static ELF: OnceLock<Elf> = OnceLock::new();
@@ -241,16 +241,6 @@ mod tests {
         run_zkvm_prove(&zkvm, &test_case);
     }
 
-    #[test]
-    fn test_unsupported_prover_resource() {
-        let elf = basic_elf();
-        let err = LambdaVMProver::new(elf, ProverResource::Gpu).err().unwrap();
-        assert!(matches!(
-            err,
-            Error::CommonError(CommonError::UnsupportedProverResourceKind { .. })
-        ));
-    }
-
     #[test]
     fn test_execute_switchable() {
         let mut zkvm = LambdaVMProver::new(basic_elf(), ProverResource::Cpu).unwrap();