pub fn verify(
        builder: &mut Builder<C>,
        machine: &StarkMachine<SC, A>,
        input: SP1CompressWitnessVariable<C, SC>,
    ) {
        // Read input.
        let SP1CompressWitnessVariable { vks_and_proofs, is_complete } = input;

        // Assert that there is only one proof, and get the verification key and proof.
        let [(vk, proof)] = vks_and_proofs.try_into().ok().unwrap();

        // Verify the stark proof.

        // Prepare a challenger.
        let mut challenger = machine.config().challenger_variable(builder);

        // Observe the vk and start pc.
        challenger.observe(builder, vk.commitment);
        challenger.observe(builder, vk.pc_start);
        challenger.observe_slice(builder, vk.initial_global_cumulative_sum.0.x.0);
        challenger.observe_slice(builder, vk.initial_global_cumulative_sum.0.y.0);
        // Observe the padding.
        let zero: Felt<_> = builder.eval(C::F::zero());
        challenger.observe(builder, zero);

        // Observe the public values.
        challenger
            .observe_slice(builder, proof.public_values[0..machine.num_pv_elts()].iter().copied());

        StarkVerifier::verify_shard(builder, &vk, machine, &mut challenger, &proof);

        // Get the public values, and assert that they are valid.
        let public_values: &RootPublicValues<Felt<C::F>> = proof.public_values.as_slice().borrow();
        assert_root_public_values_valid::<C, SC>(builder, public_values);

        // Assert the public values are of a complete proof.
        assert_complete(builder, &public_values.inner, is_complete);
        builder.assert_felt_eq(is_complete, C::F::one());

        // Reflect the public values to the next level.
        SC::commit_recursion_public_values(builder, public_values.inner);
    }
Verify a batch of recursive proofs and aggregate their public values.

The compression verifier can aggregate proofs of different kinds:
- Core proofs: proofs which are recursive proof of a batch of SP1 shard proofs. The
implementation in this function assumes a fixed recursive verifier specified by
`recursive_vk`.
- Deferred proofs: proofs which are recursive proof of a batch of deferred proofs. The
implementation in this function assumes a fixed deferred verification program specified by
`deferred_vk`.
- Compress proofs: these are proofs which refer to a prove of this program. The key for it
is part of public values will be propagated across all levels of recursion and will be
checked against itself as in [sp1_prover::Prover] or as in [super::SP1RootVerifier].
crates/recursion/circuit/src/machine/wrap.rs