Merge pull request #1044 from openfheorg/dev

Updates to v1.4

Author: yspolyakov

CMakeLists.User.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5.1)
+cmake_minimum_required(VERSION 3.16.3)
 
 ### To use gcc/g++ on a Macintosh, you must set the Compilers
 ### here, not inside the project

CMakeLists.txt

@@ -8,7 +8,7 @@
 ## An option has the value of ON or OFF
 ## See below for the list of options
 
-cmake_minimum_required(VERSION 3.5.1)
+cmake_minimum_required(VERSION 3.16.3)
 
 find_program(CCACHE_PROGRAM ccache)
 if(CCACHE_PROGRAM)
@@ -26,8 +26,8 @@ endif()
 project (OpenFHE C CXX)
 
 set(OPENFHE_VERSION_MAJOR 1)
-set(OPENFHE_VERSION_MINOR 3)
-set(OPENFHE_VERSION_PATCH 1)
+set(OPENFHE_VERSION_MINOR 4)
+set(OPENFHE_VERSION_PATCH 0)
 set(OPENFHE_VERSION ${OPENFHE_VERSION_MAJOR}.${OPENFHE_VERSION_MINOR}.${OPENFHE_VERSION_PATCH})
 
 set(CMAKE_CXX_STANDARD 17)
@@ -147,24 +147,41 @@ if("${isSystemDir}" STREQUAL "-1")
 endif("${isSystemDir}" STREQUAL "-1")
 
 # Compiler flags
+set(C_COMPILE_FLAGS "-Wall -Werror -DOPENFHE_VERSION=${OPENFHE_VERSION}")
+set(CXX_COMPILE_FLAGS "-Wall -Werror -DOPENFHE_VERSION=${OPENFHE_VERSION}")
+if(WITH_NATIVEOPT)
+    string(APPEND C_COMPILE_FLAGS " -march=native")
+    string(APPEND CXX_COMPILE_FLAGS " -march=native")
+endif()
 
-# Added -Wno-parentheses for compatibility with g++
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+set(IGNORE_WARNINGS "") # initialize IGNORE_WARNINGS
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # Add -Wno-parentheses for compatibility with g++
     set (IGNORE_WARNINGS "-Wno-parentheses")
     # we can use GNU built-in functions provided by GCC for debugging. ex: __builtin_LINE (), __builtin_FUNCTION (), __builtin_FILE ()
     add_definitions(-DBUILTIN_INFO_AVAILABLE)
     message(STATUS "BUILTIN_INFO_AVAILABLE is defined")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+        set(IGNORE_WARNINGS "-Wno-unused-private-field -Wno-shift-op-parentheses")
+    endif()
+endif()
+if(IGNORE_WARNINGS)
+    # for C++ only
+    string(APPEND CXX_COMPILE_FLAGS " ${IGNORE_WARNINGS}")
 endif()
 
-if(WITH_NATIVEOPT)
-    set(NATIVE_OPT "-march=native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(CMAKE_C_FLAGS_RELEASE "-O0 -DNDEBUG")
+    set(CMAKE_CXX_FLAGS_RELEASE "-O0 -DNDEBUG")
+
+    set(C_COMPILE_FLAGS "${C_COMPILE_FLAGS} -O0 -g")
+    set(CXX_COMPILE_FLAGS "${CXX_COMPILE_FLAGS} -O0 -g")
 else()
-    set(NATIVE_OPT "")
+    set(C_COMPILE_FLAGS "${C_COMPILE_FLAGS} -O3")
+    set(CXX_COMPILE_FLAGS "${CXX_COMPILE_FLAGS} -O3")
 endif()
 
-set(C_COMPILE_FLAGS "-Wall -Werror -O3 ${NATIVE_OPT} -DOPENFHE_VERSION=${OPENFHE_VERSION}")
-set(CXX_COMPILE_FLAGS "-Wall -Werror -O3 ${NATIVE_OPT} -DOPENFHE_VERSION=${OPENFHE_VERSION} ${IGNORE_WARNINGS}")
-
 if(EMSCRIPTEN)
     set(EMSCRIPTEN_IGNORE_WARNINGS "-Wno-unused-but-set-variable -Wno-unknown-warning-option")
     set(C_COMPILE_FLAGS "${C_COMPILE_FLAGS} ${EMSCRIPTEN_IGNORE_WARNINGS}")
@@ -677,9 +694,26 @@ add_subdirectory(src/pke)
 add_subdirectory(src/binfhe)
 
 ### build the google test handlers
-###if(BUILD_UNITTESTS)
-###	add_subdirectory(third-party/google-test EXCLUDE_FROM_ALL)
-###endif()
+if(BUILD_UNITTESTS)
+    add_subdirectory(third-party/google-test EXCLUDE_FROM_ALL)
+    ##############################################################################################################
+    ### Handle third-party/google-test/googletest's uninitialized variable dummy. Remove
+    ### add_compile_options(-Wno-error=maybe-uninitialized)
+    ### once googletest has been updated to v1.11.0 or later.
+    ##############################################################################################################
+    ### 1. This applies to gtest only
+    ### 2. Build does not fail because of "uninitialized error"
+    ### 3. We still see a warning if the variable is truly uninitialized
+    ### 4. All other warnings still remain errors
+    ##############################################################################################################
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(gtest PRIVATE -Wno-error=maybe-uninitialized)
+        target_compile_options(gtest_main PRIVATE -Wno-error=maybe-uninitialized)
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        target_compile_options(gtest PRIVATE -Wno-uninitialized)
+        target_compile_options(gtest_main PRIVATE -Wno-uninitialized)
+    endif()
+endif()
 
 ### build the google benchmark handlers (just the parts we need)
 if(BUILD_BENCHMARKS)

README.md

@@ -8,13 +8,15 @@ OpenFHE is an open-source FHE library that includes efficient implementations of
   * Cheon-Kim-Kim-Song (CKKS) scheme for real-number arithmetic (includes approximate bootstrapping)
   * Ducas-Micciancio (DM/FHEW), Chillotti-Gama-Georgieva-Izabachene (CGGI/TFHE), and Lee-Micciancio-Kim-Choi-Deryabin-Eom-Yoo (LMKCDEY) schemes for evaluating Boolean circuits and arbitrary functions over larger plaintext spaces using lookup tables
 
+OpenFHE also supports hybrid vectorized schemes, with the goal of enabling the FHEW/TFHE-like functional bootstrapping capability for schemes such as CKKS and BFV. In particular, OpenFHE supports
+  * Switching between CKKS and FHEW/TFHE to evaluate non-smooth functions, e.g., comparison, using (scalar) FHEW/TFHE functional bootstrapping
+  * Switching between RLWE (a scheme equivalent to the coefficient-encoded additive BFV scheme) and CKKS to evaluate arbitrary lookup tables over vectors of integers, e.g., modular reduction, comparison or S-box, using vectorized functional bootstrapping implemented in CKKS
+
 OpenFHE also includes the following multiparty extensions of FHE:
   * Threshold FHE for BGV, BFV, and CKKS schemes
   * Interactive bootstrapping for Threshold CKKS
   * Proxy Re-Encryption for BGV, BFV, and CKKS schemes
 
-OpenFHE also supports switching between CKKS and FHEW/TFHE to evaluate non-smooth functions, e.g., comparison, using FHEW/TFHE functional bootstrapping.
-
 OpenFHE supports any GNU C++ compiler version 9 or above and clang C++ compiler version 10 or above. To achieve the best runtime performance, we recommend following the
 guidelines outlined in [building OpenFHE for best performance](https://github.com/openfheorg/openfhe-development/blob/main/docs/static_docs/Best_Performance.md).
 
@@ -76,6 +78,8 @@ To get familiar with the main API of OpenFHE, we recommend looking at the code o
        4. [Small-Precison Arbitrary Function Evaluation](src/binfhe/examples/eval-function.cpp)
    1. Scheme Switching:
        1. [Examples with Scheme Switching between CKKS and FHEW/TFHE](src/pke/examples/scheme-switching.cpp)
+   1. Functional Bootstrapping over integers (RLWE and CKKS):
+       1. [Examples with Functional Bootstrapping using CKKS for lookup table evaluation, sign extraction and multivalue bootstrapping](src/pke/examples/functional-bootstrapping-ckks.cpp)
    1. Threshold FHE:
        1. [Code Example for BGV, BFV, and CKKS](src/pke/examples/threshold-fhe.cpp)
        1. [2-party Interactive Bootstrapping Examples](src/pke/examples/interactive-bootstrapping.cpp)

benchmark/src/Lattice.cpp

@@ -242,7 +242,7 @@ static void BM_add_LATTICE(benchmark::State& state) {
     E a;
     E b;
 
-    if (state.thread_index == 0) {
+    if (state.thread_index() == 0) {
         a = TestParameters.GetPoly<E>(state.range(0), 0);
         b = TestParameters.GetPoly<E>(state.range(0), 1);
     }
@@ -262,7 +262,7 @@ static void BM_addeq_LATTICE(benchmark::State& state) {
     E a;
     E b;
 
-    if (state.thread_index == 0) {
+    if (state.thread_index() == 0) {
         b = TestParameters.GetPoly<E>(state.range(0), 1);
         a = TestParameters.GetPoly<E>(state.range(0), 0);
     }
@@ -282,7 +282,7 @@ template <class E>
 static void BM_mult_LATTICE(benchmark::State& state) {
     E a, b;
 
-    if (state.thread_index == 0) {
+    if (state.thread_index() == 0) {
         a = TestParameters.GetPoly<E>(state.range(0), 0);
         b = TestParameters.GetPoly<E>(state.range(0), 1);
     }
@@ -301,7 +301,7 @@ template <class E>
 static void BM_multeq_LATTICE(benchmark::State& state) {
     E a, b;
 
-    if (state.thread_index == 0) {
+    if (state.thread_index() == 0) {
         b = TestParameters.GetPoly<E>(state.range(0), 1);
         a = TestParameters.GetPoly<E>(state.range(0), 0);
     }

docs/index.rst

@@ -9,14 +9,17 @@ OpenFHE is an open-source FHE library that includes efficient implementations of
   - Brakerski/Fan-Vercauteren (BFV) scheme for integer arithmetic
   - Brakerski-Gentry-Vaikuntanathan (BGV) scheme for integer arithmetic
   - Cheon-Kim-Kim-Song (CKKS) scheme for real-number arithmetic (includes approximate bootstrapping)
-  - Ducas-Micciancio (DM/FHEW) and Chillotti-Gama-Georgieva-Izabachene (CGGI/TFHE), and Lee-Micciancio-Kim-Choi-Deryabin-Eom-Yoo (LMKCDEY) schemes for evaluating Boolean circuits and arbitrary functions over larger plaintext spaces using lookup tables
+  - Ducas-Micciancio (DM/FHEW), Chillotti-Gama-Georgieva-Izabachene (CGGI/TFHE), and Lee-Micciancio-Kim-Choi-Deryabin-Eom-Yoo (LMKCDEY) schemes for evaluating Boolean circuits and arbitrary functions over larger plaintext spaces using lookup tables
+
+OpenFHE also supports hybrid vectorized schemes, with the goal of enabling the FHEW/TFHE-like functional bootstrapping capability for schemes such as CKKS and BFV. In particular, OpenFHE supports
+  - Switching between CKKS and FHEW/TFHE to evaluate non-smooth functions, e.g., comparison, using (scalar) FHEW/TFHE functional bootstrapping
+  - Switching between RLWE (a scheme equivalent to the coefficient-encoded additive BFV scheme) and CKKS to evaluate arbitrary lookup tables over vectors of integers, e.g., modular reduction, comparison or S-box, using vectorized functional bootstrapping implemented in CKKS
 
 OpenFHE also includes the following multiparty extensions of FHE:
   - Threshold FHE for BGV, BFV, and CKKS schemes
+  - Interactive bootstrapping for Threshold CKKS
   - Proxy Re-Encryption for BGV, BFV, and CKKS schemes
 
-OpenFHE also supports switching between CKKS and FHEW/TFHE to evaluate non-smooth functions, e.g., comparison, using FHEW/TFHE functional bootstrapping.
-
 OpenFHE supports any GNU C++ compiler version 9 or above and clang C++ compiler version 10 or above.
 
 A major focus is on the usability of the schemes. For instance, all HE schemes with packing use the same common API, and are implemented using runtime polymorphism.

docs/sphinx_rsts/modules/pke/pke_keys.rst

@@ -39,8 +39,6 @@ Key Class File Listings
 
 - Get and set relinearization elements
 
-- Get and set key switches for ``BinDCRT`` and ``DCRT``
-
 - Inherits from ``Eval Key``
 
 `Key (key.h) <https://github.com/openfheorg/openfhe-development/blob/main/src/pke/include/key/key.h>`_

docs/static_docs/Release_Notes.md

@@ -1,3 +1,13 @@
+08/18/2025: OpenFHE 1.4.0 (development) is released
+
+* Adds general functional bootstrapping using CKKS proposed in https://eprint.iacr.org/2024/1623 (#954)
+* Enables the sparse-secret encapsulation mode from https://eprint.iacr.org/2022/024 for regular and functional CKKS bootstrapping (#1001)
+* Adds optimized implementation (without checks) for selected homomorphic addition and multiplication operations (#991)
+* Updates google submodules (#1036)
+* Fixes several bugs
+
+The detailed list of changes is available at https://github.com/openfheorg/openfhe-development/issues?q=is%3Aissue+milestone%3A%22Release+1.4.0%22
+
 07/11/2025: OpenFHE 1.3.1 (stable) is released
 
 * Updates the noise estimation models for BGV and BFV, making them slightly more conservative (roughly 1 extra bit is added for each multiplicative level) (#1004)

src/binfhe/CMakeLists.txt

@@ -54,6 +54,7 @@ if(BUILD_UNITTESTS)
     file(GLOB BINFHE_TEST_SRC_FILES CONFIGURE_DEPENDS unittest/*.cpp)
     add_executable(binfhe_tests ${BINFHE_TEST_SRC_FILES} ${UNITTESTMAIN})
     set_property(TARGET binfhe_tests PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/unittest)
+    target_link_libraries(binfhe_tests PRIVATE gtest gtest_main)
     target_link_libraries(binfhe_tests ${BINFHELIBS} ${ADDITIONAL_LIBS})
     if(NOT ${WITH_OPENMP} AND NOT EMSCRIPTEN)
         target_link_libraries(binfhe_tests PRIVATE Threads::Threads)

src/core/CMakeLists.txt

@@ -59,6 +59,7 @@ if(BUILD_UNITTESTS)
     set(CORE_TEST_SRC_FILES ${CORE_TEST_SRC_FILES})
     add_executable(core_tests ${CORE_TEST_SRC_FILES} ${UNITTESTMAIN})
     set_property(TARGET core_tests PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/unittest)
+    target_link_libraries(core_tests PRIVATE gtest gtest_main)
     target_link_libraries(core_tests ${CORELIBS} ${ADDITIONAL_LIBS})
     if(NOT ${WITH_OPENMP} AND NOT EMSCRIPTEN)
         target_link_libraries(core_tests PRIVATE Threads::Threads)

src/core/include/lattice/constants-lattice.h

@@ -32,23 +32,27 @@
 #ifndef _CONSTANTS_LATTICE_H_
 #define _CONSTANTS_LATTICE_H_
 
+#include <cstdint>
 #include <iosfwd>
 #include <string>
-#include <cstdint>
 
 namespace lbcrypto {
 
 /**
  * @brief Lists all modes for RLWE schemes, such as BGV and BFV, and for LWE schemes, such as DM and TFHE
  */
 enum SecretKeyDist {
-    GAUSSIAN        = 0,
-    UNIFORM_TERNARY = 1,  // Default value, all schemes support this key distribution
-    SPARSE_TERNARY  = 2,
-    // BINARY = 3, // Future implementation
+    GAUSSIAN            = 0,
+    UNIFORM_TERNARY     = 1,  // Default value, all schemes support this key distribution
+    SPARSE_TERNARY      = 2,
+    SPARSE_ENCAPSULATED = 3,  // For more effient bootstrapping in SIMD schemes
+                              // (has been used for CKKS and BFV bootstrapping in literature)
+    // BINARY = X, // Future implementation
 };
+
 SecretKeyDist convertToSecretKeyDist(const std::string& str);
 SecretKeyDist convertToSecretKeyDist(uint32_t num);
+
 std::ostream& operator<<(std::ostream& s, SecretKeyDist m);
 
 }  // namespace lbcrypto