feat!: removing final machine support (#132)

## What ❔

* Removing support for 2^25 'final' machine
* We use 2^23 with delegations instead.

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: mm-zk

execution_utils/src/lib.rs

@@ -58,9 +58,6 @@ pub const FINAL_RECURSION_LAYER_VERIFIER_WITH_OUTPUT: &[u8] =
 
 pub const UNIVERSAL_CIRCUIT_VERIFIER: &[u8] = include_bytes!("../../tools/verifier/universal.bin");
 
-pub const UNIVERSAL_CIRCUIT_NO_DELEGATION_VERIFIER: &[u8] =
-    include_bytes!("../../tools/verifier/universal_no_delegation.bin");
-
 // Methods to fetch the verification keys for the binaries above.
 // They are usually refreshed with build_vk.sh
 pub fn base_layer_verifier_vk() -> VerificationKey {
@@ -112,13 +109,6 @@ pub fn universal_circuit_log_23_verifier_vk() -> VerificationKey {
     .unwrap()
 }
 
-pub fn universal_circuit_no_delegation_verifier_vk() -> VerificationKey {
-    serde_json::from_slice::<VerificationKey>(include_bytes!(
-        "../../tools/verifier/universal_no_delegation.final.vk.json"
-    ))
-    .unwrap()
-}
-
 pub fn get_padded_binary(binary: &[u8]) -> Vec<u32> {
     let mut bytecode = binary
         .as_chunks::<4>()

execution_utils/src/proofs.rs

@@ -30,7 +30,11 @@ pub struct ProofMetadata {
     pub basic_proof_count: usize,
     pub reduced_proof_count: usize,
     pub reduced_log_23_proof_count: usize,
-    pub final_proof_count: usize,
+
+    /// This field is deprecated and should not be used anymore.
+    #[serde(alias = "final_proof_count")]
+    pub deprecated_final_proof_count: usize,
+
     pub delegation_proof_count: Vec<(u32, usize)>,
     pub register_values: Vec<FinalRegisterValue>,
     // hash from current binary (from end pc and setup tree).
@@ -46,7 +50,6 @@ pub struct ProofList {
     pub basic_proofs: Vec<Proof>,
     pub reduced_proofs: Vec<Proof>,
     pub reduced_log_23_proofs: Vec<Proof>,
-    pub final_proofs: Vec<Proof>,
     pub delegation_proofs: Vec<(u32, Vec<Proof>)>,
 }
 
@@ -115,7 +118,7 @@ impl ProgramProof {
         proof_metadata: &ProofMetadata,
     ) -> ProgramProof {
         // program proof doesn't distinguish between final, reduced & basic proofs.
-        let mut base_layer_proofs = proof_list.final_proofs.clone();
+        let mut base_layer_proofs = vec![];
         base_layer_proofs.extend_from_slice(&proof_list.basic_proofs);
         base_layer_proofs.extend_from_slice(&proof_list.reduced_log_23_proofs);
         base_layer_proofs.extend_from_slice(&proof_list.reduced_proofs);
@@ -136,15 +139,14 @@ impl ProgramProof {
             // Here we're guessing - as ProgramProof doesn't distinguish between basic and reduced proofs.
             reduced_proofs: self.base_layer_proofs,
             reduced_log_23_proofs: vec![],
-            final_proofs: vec![],
             delegation_proofs: self.delegation_proofs.clone().into_iter().collect(),
         };
 
         let proof_metadata = ProofMetadata {
             basic_proof_count: 0,
             reduced_proof_count,
             reduced_log_23_proof_count: 0,
-            final_proof_count: 0,
+            deprecated_final_proof_count: 0,
             delegation_proof_count: vec![],
             register_values: self.register_final_values,
             end_params: self.end_params,
@@ -160,7 +162,6 @@ impl ProofMetadata {
         self.basic_proof_count
             + self.reduced_proof_count
             + self.reduced_log_23_proof_count
-            + self.final_proof_count
             + self
                 .delegation_proof_count
                 .iter()
@@ -194,12 +195,6 @@ impl ProofList {
                 &Path::new(output_dir).join(&format!("reduced_log_23_proof_{}.json", i)),
             );
         }
-        for (i, proof) in self.final_proofs.iter().enumerate() {
-            serialize_to_file(
-                proof,
-                &Path::new(output_dir).join(&format!("final_proof_{}.json", i)),
-            );
-        }
         for (delegation_type, proofs) in self.delegation_proofs.iter() {
             for (i, proof) in proofs.iter().enumerate() {
                 serialize_to_file(
@@ -233,13 +228,6 @@ impl ProofList {
             reduced_log_23_proofs.push(proof);
         }
 
-        let mut final_proofs = vec![];
-        for i in 0..metadata.final_proof_count {
-            let proof_path = Path::new(input_dir).join(format!("final_proof_{}.json", i));
-            let proof: Proof = deserialize_from_file(proof_path.to_str().unwrap());
-            final_proofs.push(proof);
-        }
-
         let mut delegation_proofs = vec![];
         for (delegation_type, count) in metadata.delegation_proof_count.iter() {
             let mut proofs = vec![];
@@ -256,19 +244,16 @@ impl ProofList {
             basic_proofs,
             reduced_proofs,
             reduced_log_23_proofs,
-            final_proofs,
             delegation_proofs,
         }
     }
 
     pub fn get_last_proof(&self) -> &Proof {
-        self.final_proofs.last().unwrap_or_else(|| {
-            self.basic_proofs.last().unwrap_or_else(|| {
-                self.reduced_log_23_proofs.last().unwrap_or_else(|| {
-                    self.reduced_proofs
-                        .last()
-                        .expect("Neither main proof nor reduced proof is present")
-                })
+        self.basic_proofs.last().unwrap_or_else(|| {
+            self.reduced_log_23_proofs.last().unwrap_or_else(|| {
+                self.reduced_proofs
+                    .last()
+                    .expect("Neither main proof nor reduced proof is present")
             })
         })
     }

execution_utils/src/recursion.rs

@@ -1,30 +1,25 @@
-use crate::{
-    get_padded_binary, Machine, ProofMetadata, UNIVERSAL_CIRCUIT_NO_DELEGATION_VERIFIER,
-    UNIVERSAL_CIRCUIT_VERIFIER,
-};
+use crate::{get_padded_binary, Machine, ProofMetadata, UNIVERSAL_CIRCUIT_VERIFIER};
 use clap::ValueEnum;
 use std::alloc::Global;
 
 use crate::{
-    base_layer_verifier_vk, compute_chain_encoding, final_recursion_layer_verifier_vk,
-    recursion_layer_no_delegation_verifier_vk, recursion_layer_verifier_vk,
-    recursion_log_23_layer_verifier_vk, universal_circuit_log_23_verifier_vk,
-    universal_circuit_no_delegation_verifier_vk, universal_circuit_verifier_vk,
+    compute_chain_encoding, recursion_layer_verifier_vk, recursion_log_23_layer_verifier_vk,
+    universal_circuit_log_23_verifier_vk, universal_circuit_verifier_vk,
 };
 use verifier_common::blake2s_u32::BLAKE2S_DIGEST_SIZE_U32_WORDS;
 
 /// We have two layers of recursion:
 /// 1. Reduced machine (2^22 cycles) + blake delegation
 /// 2. Here we have two options:
-///   - Final reduced machine (2^25 cycles)
+///   - Final reduced machine (2^25 cycles) - no longer supported.
 ///   - Reduced log23 machine (2^23 cycles) + blake delegation
 /// Note: end_params constant differs if we do 1 or multiple repetitions of the 2nd layer.
 /// So we need to run the 2nd layer exactly one time or at least twice.
 /// Then we can define four recursion strategies:
 #[derive(Clone, Copy, Debug, ValueEnum, PartialEq, Eq)]
 pub enum RecursionStrategy {
-    /// Does 1st layer until 2 reduced + 1 delegation then final reduced machine (always two repetitions)
-    UseFinalMachine,
+    /// UseFinalMachine is no longer supported.
+    // UseFinalMachine,
     /// Does 1st layer until 2 reduced + 1 delegation then 1 reduced 2^23 + 1 delegation (one repetition)
     UseReducedLog23Machine,
     /// Does 1st layer until N reduced + M delegation then reduced 2^23 + delegation (at least two repetitions)
@@ -46,13 +41,6 @@ impl RecursionStrategy {
         const M: usize = 2;
 
         let continue_first_layer = match self {
-            RecursionStrategy::UseFinalMachine => {
-                proof_metadata.reduced_proof_count > 2
-                    || proof_metadata
-                        .delegation_proof_count
-                        .iter()
-                        .any(|(_, x)| *x > 1)
-            }
             RecursionStrategy::UseReducedLog23Machine => {
                 proof_metadata.reduced_proof_count > 2
                     || proof_metadata
@@ -79,7 +67,6 @@ impl RecursionStrategy {
         proof_level: usize,
     ) -> bool {
         let continue_second_layer = match self {
-            RecursionStrategy::UseFinalMachine => proof_metadata.final_proof_count > 1,
             RecursionStrategy::UseReducedLog23Machine => {
                 // In this strategy we should run only one repetition of 2nd layer
                 assert!(proof_level == 0);
@@ -103,7 +90,6 @@ impl RecursionStrategy {
 
     pub fn get_second_layer_machine(&self) -> Machine {
         match self {
-            RecursionStrategy::UseFinalMachine => Machine::ReducedFinal,
             RecursionStrategy::UseReducedLog23Machine
             | RecursionStrategy::UseReducedLog23MachineMultiple
             | RecursionStrategy::UseReducedLog23MachineOnly => Machine::ReducedLog23,
@@ -112,9 +98,6 @@ impl RecursionStrategy {
 
     pub fn get_second_layer_binary(&self) -> Vec<u32> {
         match self {
-            RecursionStrategy::UseFinalMachine => {
-                get_padded_binary(UNIVERSAL_CIRCUIT_NO_DELEGATION_VERIFIER)
-            }
             RecursionStrategy::UseReducedLog23Machine
             | RecursionStrategy::UseReducedLog23MachineMultiple
             | RecursionStrategy::UseReducedLog23MachineOnly => {
@@ -124,10 +107,7 @@ impl RecursionStrategy {
     }
 
     pub fn use_final_machine(&self) -> bool {
-        match self {
-            RecursionStrategy::UseFinalMachine => true,
-            _ => false,
-        }
+        false
     }
 }
 
@@ -143,20 +123,6 @@ pub fn generate_constants_for_binary(
     let (end_params, aux_values) = if universal_verifier {
         if recompute {
             match recursion_mode {
-                RecursionStrategy::UseFinalMachine => generate_params_and_register_values(
-                    &[
-                        (&base_layer_bin, Machine::Standard),
-                        (&crate::UNIVERSAL_CIRCUIT_VERIFIER, Machine::Reduced),
-                        (
-                            &crate::UNIVERSAL_CIRCUIT_NO_DELEGATION_VERIFIER,
-                            Machine::ReducedFinal,
-                        ),
-                    ],
-                    (
-                        &crate::UNIVERSAL_CIRCUIT_NO_DELEGATION_VERIFIER,
-                        Machine::ReducedFinal,
-                    ),
-                ),
                 RecursionStrategy::UseReducedLog23Machine => generate_params_and_register_values(
                     &[
                         (&base_layer_bin, Machine::Standard),
@@ -188,19 +154,6 @@ pub fn generate_constants_for_binary(
             let base_params = generate_params_for_binary(&base_layer_bin, Machine::Standard);
 
             match recursion_mode {
-                RecursionStrategy::UseFinalMachine => {
-                    let aux_values = compute_chain_encoding(vec![
-                        [0u32; 8],
-                        base_params,
-                        universal_circuit_verifier_vk().params,
-                        universal_circuit_no_delegation_verifier_vk().params,
-                    ]);
-
-                    (
-                        universal_circuit_no_delegation_verifier_vk().params,
-                        aux_values,
-                    )
-                }
                 RecursionStrategy::UseReducedLog23Machine => {
                     let aux_values = compute_chain_encoding(vec![
                         [0u32; 8],
@@ -234,21 +187,6 @@ pub fn generate_constants_for_binary(
     } else {
         if recompute {
             match recursion_mode {
-                RecursionStrategy::UseFinalMachine => generate_params_and_register_values(
-                    &[
-                        (&base_layer_bin, Machine::Standard),
-                        (&crate::BASE_LAYER_VERIFIER, Machine::Reduced),
-                        (&crate::RECURSION_LAYER_VERIFIER, Machine::Reduced),
-                        (
-                            &crate::RECURSION_LAYER_NO_DELEGATION_VERIFIER,
-                            Machine::ReducedFinal,
-                        ),
-                    ],
-                    (
-                        &crate::FINAL_RECURSION_LAYER_VERIFIER,
-                        Machine::ReducedFinal,
-                    ),
-                ),
                 RecursionStrategy::UseReducedLog23Machine => generate_params_and_register_values(
                     &[
                         (&base_layer_bin, Machine::Standard),
@@ -263,17 +201,6 @@ pub fn generate_constants_for_binary(
             let base_params = generate_params_for_binary(&base_layer_bin, Machine::Standard);
 
             match recursion_mode {
-                RecursionStrategy::UseFinalMachine => {
-                    let aux_values = compute_chain_encoding(vec![
-                        [0u32; 8],
-                        base_params,
-                        base_layer_verifier_vk().params,
-                        recursion_layer_verifier_vk().params,
-                        recursion_layer_no_delegation_verifier_vk().params,
-                    ]);
-
-                    (final_recursion_layer_verifier_vk().params, aux_values)
-                }
                 RecursionStrategy::UseReducedLog23Machine => {
                     let aux_values = compute_chain_encoding(vec![
                         [0u32; 8],

execution_utils/src/verifiers.rs

@@ -12,7 +12,8 @@ pub enum VerifierCircuitsIdentifiers {
     // This enum is used inside tools/verifier/main.rs
     BaseLayer = 0,
     RecursionLayer = 1,
-    FinalLayer = 2,
+    // Final layer is not used / supported anymore. We use Log23 layer instead.
+    // FinalLayer = 2,
     RiscV = 3,
     /// Combine 2 proofs (from recursion layers) into one.
     // This is used in OhBender to combine previous block proof with current one.
@@ -35,7 +36,7 @@ pub fn generate_oracle_data_for_universal_verifier(
     } else if metadata.reduced_log_23_proof_count > 0 {
         oracle.insert(0, VerifierCircuitsIdentifiers::RecursionLog23Layer as u32);
     } else {
-        oracle.insert(0, VerifierCircuitsIdentifiers::FinalLayer as u32);
+        panic!("Final proofs are no longer supported. Use log23 proofs instead.");
     };
     oracle
 }
@@ -102,19 +103,7 @@ pub fn generate_oracle_data_from_metadata_and_proof_list(
 
         reduced_machine_allowed_delegation_types()
     } else {
-        oracle_data.push(metadata.final_proof_count.try_into().unwrap());
-
-        for i in 0..metadata.final_proof_count {
-            let proof = &proofs.final_proofs[i];
-            oracle_data
-                .extend(verifier_common::proof_flattener::flatten_proof_for_skeleton(proof, true));
-            for query in proof.queries.iter() {
-                oracle_data.extend(verifier_common::proof_flattener::flatten_query(query));
-            }
-        }
-
-        // For final proof - empty vec.
-        vec![]
+        panic!("No proofs");
     };
 
     for (k, _) in metadata.delegation_proof_count.iter() {

tools/cli/src/main.rs

@@ -560,7 +560,7 @@ fn flatten_all(input_metadata: &String, output_file: &String) {
     } else if metadata.reduced_proof_count > 0 {
         oracle.insert(0, VerifierCircuitsIdentifiers::RecursionLayer as u32);
     } else {
-        oracle.insert(0, VerifierCircuitsIdentifiers::FinalLayer as u32);
+        panic!("No proofs");
     };
 
     u32_to_file(output_file, &oracle);
@@ -598,11 +598,10 @@ fn verify_all(metadata_path: &String) {
         assert!(metadata.reduced_proof_count > 0);
         let output = full_statement_verifier::verify_recursion_layer();
         println!("Output is: {:?}", output);
+    } else if metadata.reduced_log_23_proof_count > 0 {
+        todo!("not implemented yet");
     } else {
-        println!("Running final recursive");
-        assert!(metadata.final_proof_count > 0);
-        let output = full_statement_verifier::verify_final_recursion_layer();
-        println!("Output is: {:?}", output);
+        panic!("No proofs");
     };
     assert!(
         verifier_common::prover::nd_source_std::try_read_word().is_none(),