observed num_instance within per-chip fork

Author: hero78119

ceno_recursion/src/zkvm_verifier/verifier.rs

@@ -166,22 +166,6 @@ pub fn verify_zkvm_proof<C: Config<F = F>>(
     );
     challenger.observe(builder, log2_max_codeword_size_felt);
 
-    iter_zip!(builder, zkvm_proof_input.chip_proofs).for_each(|ptr_vec, builder| {
-        let chip_proofs = builder.iter_ptr_get(&zkvm_proof_input.chip_proofs, ptr_vec[0]);
-        let chip_idx = builder.get(&chip_proofs, 0).idx_felt;
-        challenger.observe(builder, chip_idx);
-
-        iter_zip!(builder, chip_proofs).for_each(|ptr_vec, builder| {
-            let chip_proof = builder.iter_ptr_get(&chip_proofs, ptr_vec[0]);
-
-            iter_zip!(builder, chip_proof.num_instances).for_each(|ptr_vec, builder| {
-                let num_instance = builder.iter_ptr_get(&chip_proof.num_instances, ptr_vec[0]);
-                let num_instance = builder.unsafe_cast_var_to_felt(num_instance);
-                challenger.observe(builder, num_instance);
-            });
-        });
-    });
-
     let alpha = challenger.sample_ext(builder);
     let beta = challenger.sample_ext(builder);
 
@@ -266,6 +250,11 @@ pub fn verify_zkvm_proof<C: Config<F = F>>(
                     Usize::from(circuit_vk.get_cs().num_lks() * 4),
                 );
                 chip_challenger.observe(builder, chip_proof.idx_felt);
+                iter_zip!(builder, chip_proof.num_instances).for_each(|ptr_vec, builder| {
+                    let num_instance = builder.iter_ptr_get(&chip_proof.num_instances, ptr_vec[0]);
+                    let num_instance = builder.unsafe_cast_var_to_felt(num_instance);
+                    chip_challenger.observe(builder, num_instance);
+                });
 
                 // getting the number of dummy padding item that we used in this opcode circuit
                 let num_lks: Var<C::N> =

ceno_zkvm/src/scheme/prover.rs

@@ -177,33 +177,6 @@ impl<
             // Extract chip metadata before consuming witnesses.
             // We reuse this for both transcript appends and task construction.
             let name_and_instances = witnesses.get_witnesses_name_instance();
-            let transcript_instances = name_and_instances.iter().try_fold(
-                Vec::new(),
-                |mut acc, (name, num_instances)| -> Result<_, ZKVMError> {
-                    let pk = self.pk.circuit_pks.get(name).ok_or(ZKVMError::VKNotFound(
-                        format!("proving key for circuit {} not found", name).into(),
-                    ))?;
-
-                    // Skip OMC-init-only circuits in non-first shards.
-                    if !shard_ctx.is_first_shard() && pk.get_cs().with_omc_init_only() {
-                        return Ok(acc);
-                    }
-
-                    if num_instances.iter().sum::<usize>() == 0 {
-                        return Ok(acc);
-                    }
-
-                    let circuit_idx = self.pk.circuit_name_to_index.get(name).copied().ok_or(
-                        ZKVMError::VKNotFound(
-                            format!("circuit index for {} not found", name).into(),
-                        ),
-                    )?;
-
-                    acc.push((circuit_idx, *num_instances));
-                    Ok(acc)
-                },
-            )?;
-
             let mut structural_rmms = Vec::with_capacity(name_and_instances.len());
             // commit to opcode circuits first and then commit to table circuits, sorted by name
             for (i, chip_input) in witnesses.into_iter_sorted().enumerate() {
@@ -248,15 +221,6 @@ impl<
             PCS::write_commitment(&witin_commit, &mut transcript).map_err(ZKVMError::PCSError)?;
             exit_span!(commit_to_traces_span);
 
-            // Write (circuit_idx, num_instances) after all commitments are absorbed.
-            for (circuit_idx, num_instances) in &transcript_instances {
-                transcript.append_field_element(&E::BaseField::from_canonical_usize(*circuit_idx));
-                for num_instance in num_instances {
-                    transcript
-                        .append_field_element(&E::BaseField::from_canonical_usize(*num_instance));
-                }
-            }
-
             // Use pre-loaded fixed_mles (extracted before in_scope to avoid lifetime issues)
             let fixed_mles = fixed_mles_preload;
 
@@ -360,6 +324,10 @@ impl<
                     transcript.append_field_element(&E::BaseField::from_canonical_u64(
                         task.circuit_idx as u64,
                     ));
+                    for num_instance in task.input.num_instances {
+                        transcript
+                            .append_field_element(&E::BaseField::from_canonical_usize(num_instance));
+                    }
 
                     // SAFETY: TypeId check above (before closure) guarantees PB = GpuBackend<E, PCS>.
                     let gpu_input: ProofInput<'static, gkr_iop::gpu::GpuBackend<E, PCS>> =
@@ -396,6 +364,9 @@ impl<
             // Append circuit_idx to per-task forked transcript (matching verifier)
             transcript
                 .append_field_element(&E::BaseField::from_canonical_u64(task.circuit_idx as u64));
+            for num_instance in task.input.num_instances {
+                transcript.append_field_element(&E::BaseField::from_canonical_usize(num_instance));
+            }
 
             // Prepare: deferred extraction for GPU, no-op for CPU
             self.device.prepare_chip_input(&mut task, witness_data);

ceno_zkvm/src/scheme/verifier.rs

@@ -252,15 +252,6 @@ impl<E: ExtensionField, PCS: PolynomialCommitmentScheme<E>> ZKVMVerifier<E, PCS>
         PCS::write_commitment(&vm_proof.witin_commit, &mut transcript)
             .map_err(ZKVMError::PCSError)?;
 
-        // write (circuit_idx, num_instance) to transcript
-        for (circuit_idx, proofs) in vm_proof.chip_proofs.iter() {
-            transcript.append_field_element(&E::BaseField::from_canonical_u32(*circuit_idx as u32));
-            // length of proof.num_instances will be constrained in verify_chip_proof
-            for num_instance in proofs.iter().flat_map(|proof| &proof.num_instances) {
-                transcript.append_field_element(&E::BaseField::from_canonical_usize(*num_instance));
-            }
-        }
-
         #[cfg(debug_assertions)]
         {
             Instrumented::<<<E as ExtensionField>::BaseField as PoseidonField>::P>::log_label(
@@ -353,6 +344,9 @@ impl<E: ExtensionField, PCS: PolynomialCommitmentScheme<E>> ZKVMVerifier<E, PCS>
                 .sum::<E>();
 
             transcript.append_field_element(&E::BaseField::from_canonical_u64(*index as u64));
+            for num_instance in &proof.num_instances {
+                transcript.append_field_element(&E::BaseField::from_canonical_usize(*num_instance));
+            }
 
             // compute logup_sum padding
             // getting the number of dummy padding item that we used in this opcode circuit