FRI Implementation: frontend + CPU Backend + GPU Backend

icicle/CMakeLists.txt

@@ -38,6 +38,7 @@ option(HASH "Build hashes and tree builders" ON)
 option(POSEIDON "Build poseidon hash" ON)
 option(POSEIDON2 "Build poseidon2 hash" ON)
 option(SUMCHECK "Build sumcheck" ON)
+option(FRI "Build fri" ON)
 option(SANITIZE "Enable memory address sanitizer" OFF)
 
 # address sanitizer

icicle/backend/cpu/CMakeLists.txt

@@ -48,6 +48,9 @@ if (FIELD)
     if(SUMCHECK)
         target_sources(icicle_field PRIVATE src/field/cpu_sumcheck.cpp)
     endif()
+    if(FRI)
+        target_sources(icicle_field PRIVATE src/field/cpu_fri.cpp)
+    endif()
     target_include_directories(icicle_field PRIVATE include)
 endif() # FIELD
 

icicle/backend/cpu/include/cpu_fri_backend.h

@@ -0,0 +1,190 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+#include <random>
+#include "icicle/errors.h"
+#include "icicle/fri/fri_transcript.h"
+#include "icicle/backend/fri_backend.h"
+#include "cpu_fri_rounds.h"
+#include "cpu_ntt_domain.h"
+#include "icicle/utils/log.h"
+
+namespace icicle {
+  template <typename S, typename F>
+  class CpuFriBackend : public FriBackend<S, F>
+  {
+  public:
+    /**
+     * @brief Constructor that accepts an existing array of Merkle trees.
+     *
+     * @param folding_factor   The factor by which the codeword is folded each round.
+     * @param stopping_degree  Stopping degree threshold for the final polynomial.
+     * @param merkle_trees     A vector of MerkleTrees, tree per FRI round.
+     */
+    CpuFriBackend(const size_t folding_factor, const size_t stopping_degree, std::vector<MerkleTree> merkle_trees)
+        : FriBackend<S, F>(folding_factor, stopping_degree, std::move(merkle_trees)),
+          m_nof_fri_rounds(this->m_merkle_trees.size()),
+          m_log_input_size(this->m_merkle_trees.size() + std::log2(static_cast<double>(stopping_degree + 1))),
+          m_input_size(pow(2, m_log_input_size)), m_fri_rounds(this->m_merkle_trees, m_log_input_size)
+    {
+    }
+
+    eIcicleError get_proof(
+      const FriConfig& fri_config,
+      const FriTranscriptConfig<F>& fri_transcript_config,
+      const F* input_data,
+      FriProof<F>& fri_proof /*out*/) override
+    {
+      if (__builtin_expect(fri_config.nof_queries <= 0, 0)) { ICICLE_LOG_ERROR << "Number of queries must be > 0"; }
+
+      FriTranscript<F> transcript(fri_transcript_config, m_log_input_size);
+
+      // Initialize the proof
+      eIcicleError err = fri_proof.init(fri_config.nof_queries, m_nof_fri_rounds, this->m_stopping_degree + 1);
+      if (err != eIcicleError::SUCCESS) { return err; }
+
+      // commit fold phase
+      err = commit_fold_phase(input_data, transcript, fri_config, fri_proof);
+      if (err != eIcicleError::SUCCESS) { return err; }
+
+      // proof of work
+      if (fri_config.pow_bits != 0) {
+        err = proof_of_work(transcript, fri_config.pow_bits, fri_proof);
+        if (err != eIcicleError::SUCCESS) { return err; }
+      }
+
+      // query phase
+      err = query_phase(transcript, fri_config, fri_proof);
+
+      return err;
+    }
+
+  private:
+    const size_t m_nof_fri_rounds;
+    const size_t m_log_input_size;
+    const size_t m_input_size;
+    FriRounds<F> m_fri_rounds; // Holds intermediate rounds
+
+    /**
+     * @brief Perform the commit-fold phase of the FRI protocol.
+     *
+     * @param input_data  The initial polynomial evaluations.
+     * @param fri_proof   The proof object to update.
+     * @param transcript  The transcript to generate challenges.
+     * @return eIcicleError Error code indicating success or failure.
+     */
+    eIcicleError commit_fold_phase(
+      const F* input_data, FriTranscript<F>& transcript, const FriConfig& fri_config, FriProof<F>& fri_proof)
+    {
+      if (this->m_folding_factor != 2) {
+        ICICLE_LOG_ERROR
+          << "Currently only folding factor of 2 is supported"; // TODO SHANIE - remove when supporting other folding
+        // factors
+      }
+      const S* twiddles = ntt_cpu::CpuNttDomain<S>::s_ntt_domain.get_twiddles();
+      uint64_t domain_max_size = ntt_cpu::CpuNttDomain<S>::s_ntt_domain.get_max_size();
+      if (m_input_size > domain_max_size) {
+        ICICLE_LOG_ERROR << "Size is too large for domain. size = " << m_input_size
+                         << ", domain_max_size = " << domain_max_size;
+      }
+
+      // Retrieve pre-allocated memory for the round from m_fri_rounds.
+      // The instance of FriRounds has already allocated a vector for each round with
+      // a capacity of 2^(m_log_input_size - round_idx).
+      F* round_evals = m_fri_rounds.get_round_evals(0);
+      std::copy(input_data, input_data + m_input_size, round_evals);
+
+      size_t current_size = m_input_size;
+      size_t current_log_size = m_log_input_size;
+
+      for (size_t round_idx = 0; round_idx < m_nof_fri_rounds; ++round_idx) {
+        // Merkle tree for the current round_idx
+        MerkleTree* current_round_tree = m_fri_rounds.get_merkle_tree(round_idx);
+        current_round_tree->build(round_evals, current_size, MerkleTreeConfig());
+        auto [root_ptr, root_size] = current_round_tree->get_merkle_root();
+        if (root_ptr == nullptr || root_size <= 0) {
+          ICICLE_LOG_ERROR << "Failed to retrieve Merkle root for round " << round_idx;
+        }
+        // Add root to transcript and get alpha
+        std::vector<std::byte> merkle_commit(root_size);
+        std::memcpy(merkle_commit.data(), root_ptr, root_size);
+
+        F alpha = transcript.get_alpha(merkle_commit, round_idx == 0);
+
+        // Fold the evaluations
+        size_t half = current_size >> 1;
+        std::vector<F> peven(half);
+        std::vector<F> podd(half);
+
+        for (size_t i = 0; i < half; ++i) {
+          peven[i] = (round_evals[i] + round_evals[i + half]) * S::inv_log_size(1);
+          uint64_t tw_idx = domain_max_size - ((domain_max_size >> current_log_size) * i);
+          podd[i] = ((round_evals[i] - round_evals[i + half]) * S::inv_log_size(1)) * twiddles[tw_idx];
+        }
+
+        if (round_idx == m_nof_fri_rounds - 1) {
+          round_evals = fri_proof.get_final_poly();
+        } else {
+          round_evals = m_fri_rounds.get_round_evals(round_idx + 1);
+        }
+
+        for (size_t i = 0; i < half; ++i) {
+          round_evals[i] = peven[i] + (alpha * podd[i]);
+        }
+
+        current_size >>= 1;
+        current_log_size--;
+      }
+      return eIcicleError::SUCCESS;
+    }
+
+    eIcicleError proof_of_work(FriTranscript<F>& transcript, const size_t pow_bits, FriProof<F>& fri_proof)
+    {
+      for (uint64_t nonce = 0; nonce < UINT64_MAX; nonce++) {
+        if (transcript.hash_and_get_nof_leading_zero_bits(nonce) == pow_bits) {
+          transcript.set_pow_nonce(nonce);
+          fri_proof.set_pow_nonce(nonce);
+          return eIcicleError::SUCCESS;
+        }
+      }
+      ICICLE_LOG_ERROR << "Failed to find a proof-of-work nonce";
+      return eIcicleError::UNKNOWN_ERROR;
+    }
+
+    /**
+     * @brief Perform the query phase of the FRI protocol.
+     *
+     * @param transcript      The transcript object.
+     * @param fri_config      The FRI configuration object.
+     * @param fri_proof       (OUT) The proof object where we store the resulting Merkle proofs.
+     * @return eIcicleError
+     */
+    eIcicleError query_phase(FriTranscript<F>& transcript, const FriConfig& fri_config, FriProof<F>& fri_proof)
+    {
+      std::vector<size_t> queries_indicies =
+        transcript.rand_queries_indicies(fri_config.nof_queries, (this->m_stopping_degree + 1), m_input_size);
+      for (size_t query_idx = 0; query_idx < fri_config.nof_queries; query_idx++) {
+        size_t query = queries_indicies[query_idx];
+        for (size_t round_idx = 0; round_idx < m_nof_fri_rounds; round_idx++) {
+          size_t round_size = (1ULL << (m_log_input_size - round_idx));
+          size_t leaf_idx = query % round_size;
+          size_t leaf_idx_sym = (query + (round_size >> 1)) % round_size;
+          F* round_evals = m_fri_rounds.get_round_evals(round_idx);
+
+          MerkleProof& proof_ref = fri_proof.get_query_proof(2 * query_idx, round_idx);
+          eIcicleError err = m_fri_rounds.get_merkle_tree(round_idx)->get_merkle_proof(
+            round_evals, round_size, leaf_idx, false /* is_pruned */, MerkleTreeConfig(), proof_ref);
+          if (err != eIcicleError::SUCCESS) return err;
+          MerkleProof& proof_ref_sym = fri_proof.get_query_proof(2 * query_idx + 1, round_idx);
+          eIcicleError err_sym = m_fri_rounds.get_merkle_tree(round_idx)->get_merkle_proof(
+            round_evals, round_size, leaf_idx_sym, false /* is_pruned */, MerkleTreeConfig(), proof_ref_sym);
+          if (err_sym != eIcicleError::SUCCESS) return err_sym;
+        }
+      }
+      return eIcicleError::SUCCESS;
+    }
+  };
+
+} // namespace icicle

icicle/backend/cpu/include/cpu_fri_rounds.h

@@ -0,0 +1,68 @@
+namespace icicle {
+
+  template <typename F>
+  class FriRounds
+  {
+  public:
+    /**
+     * @brief Constructor that accepts an already-existing array of Merkle trees.
+     *        Ownership is transferred from the caller.
+     *
+     * @param merkle_trees A vector of MerkleTrees.
+     * @param log_input_size The log of the input size.
+     */
+    FriRounds(std::vector<MerkleTree>& merkle_trees, const size_t log_input_size) : m_merkle_trees(merkle_trees)
+    {
+      size_t fold_rounds = m_merkle_trees.size();
+      m_rounds_evals.resize(fold_rounds);
+      for (size_t i = 0; i < fold_rounds; i++) {
+        m_rounds_evals[i] = std::make_unique<F[]>(1ULL << (log_input_size - i));
+      }
+    }
+
+    /**
+     * @brief Get the Merkle tree for a specific fri round.
+     *
+     * @param round_idx The index of the fri round.
+     * @return A pointer to the Merkle tree backend for the specified fri round.
+     */
+    MerkleTree* get_merkle_tree(size_t round_idx)
+    {
+      if (round_idx >= m_merkle_trees.size()) {
+        ICICLE_LOG_ERROR << "round index out of bounds";
+        return nullptr;
+      }
+      return &m_merkle_trees[round_idx];
+    }
+
+    F* get_round_evals(size_t round_idx)
+    {
+      if (round_idx >= m_merkle_trees.size()) {
+        ICICLE_LOG_ERROR << "round index out of bounds";
+        return nullptr;
+      }
+      return m_rounds_evals[round_idx].get();
+    }
+
+    /**
+     * @brief Retrieve the Merkle root for a specific fri round.
+     *
+     * @param round_idx The index of the round.
+     * @return A pair containing a pointer to the Merkle root bytes and its size.
+     */
+    std::pair<const std::byte*, size_t> get_merkle_root_for_round(size_t round_idx) const
+    {
+      if (round_idx >= m_merkle_trees.size()) { return {nullptr, 0}; }
+      return m_merkle_trees[round_idx].get_merkle_root();
+    }
+
+  private:
+    // Persistent polynomial evaluations for each round (heap allocated).
+    // For round i, the expected length is 2^(m_initial_log_size - i).
+    std::vector<std::unique_ptr<F[]>> m_rounds_evals;
+
+    // Holds MerkleTree for each round. m_merkle_trees[i] is the tree for round i.
+    std::vector<MerkleTree>& m_merkle_trees;
+  };
+
+} // namespace icicle

icicle/backend/cpu/src/field/cpu_fri.cpp

@@ -0,0 +1,26 @@
+#include "icicle/backend/fri_backend.h"
+#include "cpu_fri_backend.h"
+
+using namespace field_config;
+using namespace icicle;
+
+namespace icicle {
+
+  template <typename S, typename F>
+  eIcicleError cpu_create_fri_backend(
+    const Device& device,
+    const size_t folding_factor,
+    const size_t stopping_degree,
+    std::vector<MerkleTree> merkle_trees,
+    std::shared_ptr<FriBackend<S, F>>& backend /*OUT*/)
+  {
+    backend = std::make_shared<CpuFriBackend<S, F>>(folding_factor, stopping_degree, std::move(merkle_trees));
+    return eIcicleError::SUCCESS;
+  }
+
+  REGISTER_FRI_FACTORY_BACKEND("CPU", (cpu_create_fri_backend<scalar_t, scalar_t>));
+#ifdef EXT_FIELD
+  REGISTER_FRI_EXT_FACTORY_BACKEND("CPU", (cpu_create_fri_backend<scalar_t, extension_t>));
+#endif // EXT_FIELD
+
+} // namespace icicle

icicle/cmake/features.cmake

@@ -2,19 +2,19 @@
 # Define available field libraries with an index and their supported features
 # Format: index:field:features
 set(ICICLE_FIELDS
-  1001:babybear:NTT,EXT_FIELD,POSEIDON,POSEIDON2,SUMCHECK
-  1002:stark252:NTT,POSEIDON,POSEIDON2,SUMCHECK
+  1001:babybear:NTT,EXT_FIELD,POSEIDON,POSEIDON2,SUMCHECK,FRI
+  1002:stark252:NTT,POSEIDON,POSEIDON2,SUMCHECK,FRI
   1003:m31:EXT_FIELD,POSEIDON,POSEIDON2,SUMCHECK
-  1004:koalabear:NTT,EXT_FIELD,POSEIDON,POSEIDON2,SUMCHECK
+  1004:koalabear:NTT,EXT_FIELD,POSEIDON,POSEIDON2,SUMCHECK,FRI
 )
 
 # Define available curve libraries with an index and their supported features
 # Format: index:curve:features
 set(ICICLE_CURVES
-  1:bn254:NTT,MSM,G2,ECNTT,POSEIDON,POSEIDON2,SUMCHECK
-  2:bls12_381:NTT,MSM,G2,ECNTT,POSEIDON,POSEIDON2,SUMCHECK
-  3:bls12_377:NTT,MSM,G2,ECNTT,POSEIDON,POSEIDON2,SUMCHECK
-  4:bw6_761:NTT,MSM,G2,ECNTT,POSEIDON,POSEIDON2,SUMCHECK
+  1:bn254:NTT,MSM,G2,ECNTT,POSEIDON,POSEIDON2,SUMCHECK,FRI
+  2:bls12_381:NTT,MSM,G2,ECNTT,POSEIDON,POSEIDON2,SUMCHECK,FRI
+  3:bls12_377:NTT,MSM,G2,ECNTT,POSEIDON,POSEIDON2,SUMCHECK,FRI
+  4:bw6_761:NTT,MSM,G2,ECNTT,POSEIDON,POSEIDON2,SUMCHECK,FRI
   5:grumpkin:MSM,POSEIDON,POSEIDON2,SUMCHECK
 )
 

icicle/cmake/field.cmake

@@ -53,6 +53,7 @@ function(setup_field_target FIELD FIELD_INDEX FEATURES_STRING)
   handle_poseidon(icicle_field "${FEATURES_LIST}")
   handle_poseidon2(icicle_field "${FEATURES_LIST}")
   handle_sumcheck(icicle_field "${FEATURES_LIST}")
+  handle_fri(icicle_field "${FEATURES_LIST}")
   # Add additional feature handling calls here
 
   set_target_properties(icicle_field PROPERTIES OUTPUT_NAME "icicle_field_${FIELD}")

icicle/cmake/target_editor.cmake

@@ -107,3 +107,14 @@ function(handle_sumcheck TARGET FEATURE_LIST)
     set(SUMCHECK OFF CACHE BOOL "SUMCHECK not available for this field" FORCE)
   endif()
 endfunction()
+
+function(handle_fri TARGET FEATURE_LIST)
+  if(FRI AND "FRI" IN_LIST FEATURE_LIST)
+    target_compile_definitions(${TARGET} PUBLIC FRI=${FRI})
+    target_sources(${TARGET} PRIVATE src/fri/fri.cpp)
+    target_link_libraries(${TARGET} PRIVATE icicle_hash)
+    set(FRI ON CACHE BOOL "Enable FRI feature" FORCE)
+  else()
+    set(FRI OFF CACHE BOOL "FRI not available for this field" FORCE)
+  endif()
+endfunction()