ComputeFHE: A Privacy-Preserving General-Purpose Computation Library Faris Serdar TAŞELa , Efe ÇİFTCİb
arXiv:2606.24379v1 [cs.CR] 23 Jun 2026
a
Department of Computer Engineering, Çankaya University, Ankara, Turkey, [email protected] b Computer Programming Program, Çankaya University, Ankara, Turkey, [email protected]
Abstract Fully Homomorphic Encryption (FHE) enables computations to be performed directly on encrypted data while preserving data confidentiality. However, its practical applications remain limited by high computational costs and development complexity. This paper presents ComputeFHE, an open-source C++ library that facilitates the development of privacy-preserving applications based on the TFHE cryptosystem. The library provides encrypted integer and fixed-point data types together with arithmetic, logical, comparison, conditional, and oblivious array-access operations which allow developers to implement algorithms using a familiar imperative programming paradigm. ComputeFHE supports both conventional TFHE arithmetic based on standard two-input logic gates and an optimized Arithmetic Logic Unit (ALU) architecture utilizing FHE-friendly logic primitives. Experimental results demonstrate significant reductions in the number of required bootstrapping operations, achieving performance improvements of up to 3.9× for selected operations. In addition, the library includes a simulation mode that enables testing, debugging, and complexity analysis without performing actual cryptographic computations while providing circuit complexity and bootstrapping costs. Built on top of OpenFHE, ComputeFHE offers a practical and accessible framework for developing and evaluating privacy-preserving algorithms and applications. Keywords: Fully Homomorphic Encryption, Privacy-Preserving Computing, Secure Computation Framework
Nr. Code metadata description C1 Current code version C2 Permanent GitHub link to code/repository used for this code version C3 Legal Code License C4 Code versioning system used C5 Software code languages, tools, and services used C6 Compilation requirements, operating environments & dependencies
C7 C8
If available Link to developer documentation/manual Support email for questions
Metadata 1.0 https://github.com/fstasel/ compute-fhe MIT Git C++, CMake. A modern GNU/Linux system with development files for OpenFHE installed. Alternatively, a Dockerfile is provided for easily setting up a preconfigured environment. https://github.com/fstasel/ compute-fhe#readme [email protected]
Table 1: Code metadata
Required Metadata Current code version 1. Motivation and significance Homomorphic encryption is an encryption paradigm that enables computations to be performed directly on encrypted data without requiring the underlying plaintext to be decrypted [1]. This encryption technique allows privacy-sensitive information shared in encrypted form to be processed by a service provider while ensuring that the computation results also remain encrypted. When necessary, the resulting ciphertext can later be decrypted using the appropriate key to reveal the original content. The variant of homomorphic encryption that supports an unrestricted number of computations on encrypted data is referred to as Fully Homomorphic Encryption (FHE) [1, 2]. Prominent examples include TFHE (Torus FHE, also known as CGGI–Chillotti-Gama-GeorgievaIzabachène) [3, 4] and CKKS (Cheon-Kim-Kim-Song) [5].
2
In FHE schemes, one of the key elements ensuring data security is noise1 . During homomorphic computations, this noise accumulates progressively, eventually rendering further computations infeasible. Therefore, to enable continuous processing of encrypted data, a procedure known as bootstrapping must be periodically applied to reduce the noise level [6]. However, in current approaches, bootstrapping requires substantial computational resources and constitutes a major bottleneck in practical applications [7, 8, 9]. Consequently, any optimization capable of improving efficiency is of critical importance in FHE systems. TFHE is a prominent cryptosystem that enables unlimited encrypted computation through basic logic gates or lookup tables (LUTs) [3, 4]. In this cryptosystem, the complexity of the bootstrapping operation depends on both the complexity of the homomorphic computation being performed and the targeted security level. ComputeFHE is a library designed for general-purpose computation based on the TFHE gate-based approach, utilizing optimized gates that reduce the number of bootstrapping operations and enable encrypteddata processing using C-style programming techniques. Through this library, developers can use encrypted data for various purposes, including arithmetic, logical and comparison operations, conditional execution, and oblivious array access2 , which allows for the implementation of privacy-preserving variants of diverse algorithms. OpenFHE3 library, which is used by ComputeFHE as its backend, provides support for fundamental homomorphic operations across various FHE cryptosystems (e.g., TFHE and CKKS) and multiple security levels. Another important library capable of performing tasks similar to those of ComputeFHE is Concrete4 , which enables privacypreserving computations by leveraging TFHE’s non-linear lookup table (LUT) mapping capability [10]. In addition, ConcreteML5 , built on top of Concrete, applies machine learning methods within the homomorphic encryption framework [11]. Furthermore, TFHE also has 1
https://docs.zama.org/tfhe-rs/explanations/tfhe-deep-dive Reading or writing an array element without revealing which index was accessed, hiding the memory access pattern from observers. 3 https://github.com/openfheorg/openfhe-development 4 https://github.com/zama-ai/concrete 5 https://github.com/zama-ai/concrete-ml 2
3
a GPU-accelerated Rust implementation called TFHE-rs6 which provides low-level backend [12]. HELM7 is a compiler-based toolchain designed to advance privacypreserving computation by automatically converting high-level hardware descriptions into efficient, FHE-compatible circuits. It maps complex logic into a variety of gate-level or lookup table structures based on the target circuit’s specific requirements [13]. Furthermore, BOLT introduces a specialized synthesis layer that focuses on the high computational cost of bootstrapping. It rewrites sub-networks into more compact, functionally equivalent forms to reduce the necessary number of bootstrapping operations [14]. 2. Software description ComputeFHE is a C++ library based on the TFHE cryptosystem that performs homomorphic arithmetic and logical operations on encrypted data types using logic-gate components. The library enables algorithmic design on encrypted data without departing from the principles of imperative programming. In this way, developers who are not experts in homomorphic computation processes can still contribute to the development of algorithms that allow service providers to process data in a privacy-preserving manner, while remaining within the familiar programming paradigm and syntax of conventional C++. To facilitate computation over encrypted data, ComputeFHE provides predefined encrypted integer and fixed-point data types, as well as encrypted conditional statements and vector structures that are fully compatible with these data types. ComputeFHE provides both standard implementations of Arithmetic Logic Unit (ALU) operations using basic logic gates and optimized implementations based on the FHE-friendly specialized gates proposed in [15]. In addition, the ComputeFHE library enables simulation of the developed application without requiring actual high-performance computational resources. It can also generate statistical metrics, such as the number of bootstrapping operations and logic-gate utilization, to estimate the actual computational cost. 6 7
https://github.com/zama-ai/tfhe-rs https://github.com/TrustworthyComputing/helm
4
Figure 1: UML Diagram for ComputeFHE
ComputeFHE utilizes the OpenFHE library to provide the fundamental TFHE functionalities, including key generation, encryption, decryption, and homomorphic computation. The OpenFHE library employs recommended cryptosystem parameters which corresponds to various security levels, such as 128-, 192-, and 256-bit security, supports multiple bootstrapping techniques, and provides implementations of fundamental logic-gate operations, including AND, OR, XOR, and related binary operators. Furthermore, OpenFHE supports HEXL [16] library and leverages AVX-512 processor instructions, and ComputeFHE is naturally compatible with it as well. 2.1 Software architecture: The ComputeFHE library consists of the core, C++ utilities, and simulator modules to perform homomorphic arithmetic and logical operations. A class diagram of the library is illustrated in Figure 1. These modules and their corresponding submodules are described below: i. Core modules: • ComputeFHE: The main module of the library, responsible for initializing the TFHE cryptographic context with various security levels and ALU optimization configurations, as well as integrating the associated submodules. • BaseALU: The base class that provides an interface between the low-level implementations of arithmetic and log5
ical operations and the application programming interfaces (APIs). It enables the integration of different ALU architectures and designs. • StandardALU: Baseline ALU implementation utilizing two-input logic gates. • OptimizedALU: Optimized ALU implementation utilizing specialized three-input logic gates and more efficient algorithms. • FixedPoint: Fundamental fixed-point structure for the low-level API, serving as a proxy object for both plaintext and encrypted integral data types. ii. C++ utility modules: • Condition Manager: It provides necessary mechanisms, which implements the functionality of encrypted conditional statements and manages the states of encrypted variables accordingly. • Einteger: It provides an integer data structure supporting various bit widths, with arithmetic and logical operators defined for encrypted computation. • Efixedpoint: It provides a fixed-point data structure supporting configurable integer and fractional bit widths, with fixed-point arithmetic operators defined for encrypted computation. • Evector: A module extending the standard vector structure to enable access to encrypted data using both plain and encrypted indices. iii. Simulator modules: • BaseALU Simulator: The base class responsible for enabling the integration of different ALU simulators. • StandardALU Simulator: A module that enables the StandardALU module to operate in simulation mode. • OptimizedALU Simulator: A module that enables the OptimizedALU module to operate in simulation mode.
6
2.2 Software functionalities: ComputeFHE library has several functionalities that enable homomorphic data processing by adopting an imperative programming paradigm over encrypted data, as summarized below: • The library provides template-based integral data types supporting arbitrary bit widths (up to 64 bits) (e.g., EInt<n_bits, is_signed>) and fixed-point data types parameterized by the programmer (e.g., EFix<n_bits, n_fraction_bits, is _signed>), as well as predefined C-like encrypted signed and unsigned integer types such as Eint8 and Euint32. Variables of these types can be initialized and assigned in a C-like manner. • Arithmetic and logical operations between encrypted data types (ciphertext – ciphertext operations) are fully implemented within the library. • Arithmetic and logical operations between encrypted and plain data types (ciphertext – plaintext operations), which enable additional optimizations, are also implemented. • Currently, the library supports both a baseline ALU (ALU _STANDARD), implemented using conventional arithmetic computation methods [15] based on basic two-input logic gates (e.g., AND, OR, XOR), and an optimized ALU (ALU_OPTIMIZED) constructed using TFHE-friendly three-input logic gates such as Majority and MulAdd [15, 17]. • Oblivious array access is supported through the encrypted vector implementation (Evector). • An implementation of encrypted conditional statements, provided through the Eif macro, is available to enable the modification of encrypted variables based on encrypted conditions. • The library supports a client mode that enables automatic encryption through variable initialization and assignment, as well as automatic decryption during conversion to plaintext. Similarly, a server mode is provided to enable optimized operations on encrypted data where plaintexts are involved. • The simulation mode emulates ALU operations efficiently for testing and debugging purposes, while reporting the underlying logical primitives together with the required bootstrapping operations to estimate real execution performance.
7
3. Illustrative examples ComputeFHE comes with a selection of sample algorithms and examples. Among them is the quickstart program8 , which introduces basics (i.e., initialization, variable declaration, encryption decisions) of ComputeFHE syntax to the user: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
# include < computefhe / ComputeFHE .h > using namespace computefhe ; using namespace std ; int main () { // initialize with toy security and optimized ALU logic Init ( CCPARAM_TOY , ALU_OPTIMIZED , true ); // encrypt some values Euint8 a = 42; Euint8 b = 10; // perform homomorphic addition Euint8 sum = a + b ; // use encrypted conditional branching Eif ( sum > 50) { sum -= 5; } else { sum += 5; } // decrypt and print // ( conversion to primitive types triggers decryption ) cout << " Result : " << ( uint32_t ) sum << endl ; // terminate cfhe - context Finalize (); return 0; }
The output of the quickstart example is illustrated in Figure 2. The standard implementation (Figure 2a), which can be toggled by using ALU_STANDARD as the 2nd parameter of the Init() function, requires 91 bootstrapping operations, whereas the optimized variant (Figure 2b) reduces this count to 52. Similarly, the output for the sorting (Batcher odd-even mergesort algorithm) example9 is presented in Figure 3. As with the previous example, the optimized version (Figure 3b) performs significantly fewer 8 9
https://github.com/fstasel/compute-fhe/blob/master/src/examples/quickstart.cpp https://github.com/fstasel/compute-fhe/blob/master/src/examples/sort.cpp
8
Figure 2: Quickstart example. (a) Standard ALU implementation, (b) Optimized ALU implementation.
Figure 3: Encrypted sort example. (a) Standard (b) Optimized
bootstrapping operations (2,016) compared to the standard implementation (Figure 3a), which requires 3,843 bootstrapping operations. The src/examples directory of the ComputeFHE repository provides further implementations illustrating how to execute encrypted operations on several data types, such as integers, fixed-point numbers, character strings, and oblivious-indexed arrays. 4. Impact Homomorphic encryption development typically requires the use of complex techniques and a substantial understanding of the underlying cryptographic mechanisms. In contrast, deep expertise in homomorphic encryption is not required for developers to begin using ComputeFHE. The library provides an intuitive, C-like programming interface that enables rapid development of applications operating on encrypted data. 9
Encrypted variables can be created using encrypted counterparts of familiar C-style data types. Initialization and assignment operations automatically trigger encryption, while conversion back to plaintext automatically performs decryption. As a result, developers can perform arithmetic, logical, and comparison operations on encrypted variables in much the same way as they would on conventional C/C++ variables. In addition to encrypted integer data types, the library also supports encrypted fixed-point data types for processing approximate fractional values. Although fixed-point representations do not provide the same flexibility as floating-point arithmetic, they offer significantly lower computational overhead, making them particularly attractive in the context of FHE. Furthermore, all data types provided by the library can be instantiated with application-specific bit widths. This capability is especially important in FHE applications, where minimizing operand sizes can substantially reduce computational cost and avoid unnecessary operations. The library supports encrypted conditional statements (i.e., Eif), allowing nested if and else constructs based on encrypted Booleans. Internally, this functionality is realized by tracking variables affected by encrypted conditions and automatically resolving the final program state through multiplexing operations based on the outcome of the corresponding encrypted predicates. This allows developers to express conditional logic using familiar imperative programming constructs while preserving data confidentiality. Another important feature of the library is support for oblivious array access. To achieve this, the standard C++ vector container has been extended to provide both read and write access to encrypted array elements using either plaintext or encrypted indices. This functionality enables the implementation of algorithms whose memory-access patterns must remain hidden from the service provider. ComputeFHE utilizes OpenFHE as its backend framework. The fundamental homomorphic logic-gate implementations provided by OpenFHE form the basis of the standard ALU implementation. In addition, the specialized gates required for the optimized ALU design have been implemented using OpenFHE’s low-level homomorphic primitives. Performance improvements provided by OpenFHE, including parallelized execution and hardware acceleration through the HEXL library, are 10
naturally inherited by ComputeFHE and directly contribute to its overall efficiency. ComputeFHE provides two alternative ALU implementations: StandardALU and OptimizedALU. The StandardALU serves as a baseline implementation based on conventional homomorphic arithmetic techniques. In contrast, OptimizedALU employs FHE-friendly specialized gates to perform arithmetic, logical, and shift operations more efficiently. These optimizations reduce the number of required bootstrapping operations and consequently improve performance. Furthermore, the error characteristics of the optimized implementations have been investigated and compared against standard logic-gate-based designs, and their feasibility has been demonstrated in [15]. Compared with the standard implementation, the optimized version provides substantial executiontime improvements at the cost of only a modest increase in memory consumption. Performance comparisons for selected operations are presented in Table 2. As shown in the table, the optimized ALU significantly reduces the number of required bootstrapping operations compared with the standard ALU implementation. One notable exception is the equality and inequality operators, for which the bootstrapping count remains unchanged, as the corresponding standard implementation is already near-optimal. As expected, the number of required bootstrapping operations increases with the bit width of the data type. However, the performance advantage of the optimized ALU also becomes more effective as the operand size grows, which results in greater relative savings for larger data types. It is also worth noting that oblivious array access benefits from the optimized ALU implementation; nevertheless, it still exhibits a computational complexity of O(n). Consequently, although its execution cost can be reduced through ALU-level optimizations, oblivious array access remains computationally expensive and should be used sparingly to avoid unnecessary invocations whenever possible. ComputeFHE further improves efficiency by executing ciphertext – plaintext operations more efficiently than ciphertext – ciphertext operations, thereby reducing the number of costly homomorphic computations and avoiding unnecessary bootstrapping procedures whenever possible.
11
Operation # of bits Add / Sub Mul Div / Mod 8-bit Equ / Inequ Cmp Add / Sub Mul Div / Mod 16-bit Equ / Inequ Cmp Add / Sub Mul 32-bit Div / Mod Equ / Inequ Cmp Integer Sqrta 64-bit Oblivious array access (read) Oblivious array access (write) Batcher Odd-even Mergesort
# of BS Operations ALU_STD ALU_OPT 34 15 136 78 528 248 15 15 29 8 74 31 648 346 2328 1008 31 31 61 16 154 63 2824 1458 9768 4064 63 63 125 32 9954 5706 2.23 b 1.23 b b 3.23 2.23 b c 1.79 0.94 c
Gain 2.27× 1.74× 2.13× 1× 3.63× 2.39× 1.87× 2.31× 1× 3.81× 2.60× 1.94× 2.40× 1× 3.91× 1.74× 1.81× 1.45× 1.91×
Binary restoring square root algorithm Average # of BS per (array size × bitsize) c Average # of BS per (nlog22 (n) × bitsize) where n denotes the input size a
b
Table 2: Number of bootstrapping operations required using standard and optimized ALU and corresponding gains across different homomorphic operations
Although ComputeFHE includes optimized arithmetic and logical implementations, additional optimizations may still be possible at the algorithm-design level. Certain algorithms are inherently more FHEfriendly than others and may therefore achieve superior performance. Moreover, because different arithmetic operations incur different computational costs, avoiding unnecessary arithmetic computations, reformulating expressions using lighter-weight operations, or replacing arithmetic with logical operations when appropriate can significantly improve efficiency. To facilitate such low-level optimizations, ComputeFHE provides access to ALU intrinsics. These interfaces allow developers to invoke instruction-level operations directly and access internal ALU flags, such as the carry flag. Furthermore, new instructions can be developed and integrated into the framework whenever a particular operation can be implemented more efficiently in TFHE than through conventional C/C++ constructs. For example, the specialized SwapIf instruction provides a more efficient 12
implementation of conditional swapping than a conventional if-based swap operation. One of the most significant features of ComputeFHE is its simulation mode. This mode enables execution simulation without requiring any modifications to the application code. It allows developers to estimate the homomorphic complexity of an algorithm, including its computational and memory requirements, without performing actual cryptographic computations. Consequently, the simulator serves as a valuable tool for debugging, testing, and early-stage performance analysis. ComputeFHE can be installed conveniently through Docker, providing a fast and hassle-free deployment experience. On bare-metal systems, installation typically requires configuring a suitable GNU/Linux development environment, installing the necessary compiler toolchains and dependencies, and subsequently building and installing OpenFHE. Docker eliminates much of this setup complexity. Using the Dockerfile distributed with ComputeFHE, users can generate a fully configured ComputeFHE image with all dependencies preinstalled. Modern development environments such as Visual Studio Code can connect directly to this containerized environment through Docker extensions, which enables platform-independent software development using ComputeFHE. Currently, ComputeFHE does not provide support for encrypted floatingpoint arithmetic. Although this limitation is partially mitigated through the availability of encrypted fixed-point data types, fixed-point arithmetic cannot fully match the flexibility and dynamic range offered by floating-point representations. In addition, oblivious array access remains computationally expensive and would benefit from further optimization. Consequently, developers are strongly encouraged to design algorithms that minimize unnecessary array accesses whenever possible. 5. Conclusion ComputeFHE is an easy-to-use C++ library that enables fully homomorphic computation without requiring advanced expertise in FHE. The library provides implementations of encrypted integral and fixedpoint data types together with the arithmetic and logical operations. Moreover, it includes encrypted conditional statements and oblivious array access mechanisms, which allow developers to design algorithms over encrypted data while maintaining a familiar programming model. 13
One of the distinguishing features of the library is its support for both conventional TFHE arithmetic implementations based on standard two-input logic gates and optimized ALU architectures built using FHE-friendly logic primitives. These optimized implementations significantly reduce the number of required bootstrapping operations and improve overall computational efficiency. Another important feature is the simulation mode, which allows applications to be executed for testing and debugging purposes without requiring substantial computational resources or memory consumption and without any modifications to the original implementation. During execution, the simulator also provides statistical information about the underlying circuits, including estimates of the logical operations and bootstrapping costs that would be incurred during actual homomorphic execution. Several research directions are planned as future work. These include the investigation of optimized encrypted floating-point representations, which are also of considerable interest in machine learning applications, as well as further optimizations for division operations, oblivious array access, and blind shift and rotation operations in which the shift amount remains encrypted. In addition, research will focus on the automatic detection of optimization opportunities within application code, including techniques for eliminating redundant recomputations and improving circuit efficiency. Additional areas of interest include automatic detection and optimization of squaring operations, further optimization of encrypted conditional statements, and higher-level parallelization strategies aimed at improving CPU and GPU utilization during homomorphic computation. Furthermore, depending on application requirements, future work will explore optimized implementations of encrypted algorithms in several application domains, including encrypted signal and image processing, privacy-preserving machine learning, and privacy-preserving steganography and steganalysis.
14
References [1] T. V. T. Doan, M.-L. Messai, G. Gavin, J. Darmont, A survey on implementations of homomorphic encryption schemes: Dt van thao et al., The Journal of Supercomputing 79 (13) (2023) 15098–15139. doi:10.1007/s11227-023-05233-z. [2] C. Gentry, Fully homomorphic encryption using ideal lattices, in: Proceedings of the forty-first annual ACM symposium on Theory of computing, 2009, pp. 169–178. doi:10.1145/1536414.1536440. [3] I. Chillotti, N. Gama, M. Georgieva, M. Izabachene, Faster fully homomorphic encryption: Bootstrapping in less than 0.1 seconds, in: international conference on the theory and application of cryptology and information security, Springer, 2016, pp. 3–33. doi:10.1007/ 978-3-662-53887-6_1. [4] I. Chillotti, N. Gama, M. Georgieva, M. Izabachène, Faster packed homomorphic operations and efficient circuit bootstrapping for tfhe, in: International Conference on the Theory and Application of Cryptology and Information Security, Springer, 2017, pp. 377–408. doi: 10.1007/978-3-319-70694-8_14. [5] J. H. Cheon, K. Han, A. Kim, M. Kim, Y. Song, A full rns variant of approximate homomorphic encryption, in: International Conference on Selected Areas in Cryptography, Springer, 2018, pp. 347–368. doi: 10.1007/978-3-030-10970-7_16. [6] L. Bai, L. Bai, Y. Li, Z. Li, Research on noise management technology for fully homomorphic encryption, IEEE Access 12 (2024) 135564–135576. doi:10.1109/ACCESS.2024.3461729. [7] L. Bergerat, J.-B. Orfila, A. Roux-Langlois, S. Tap, Accelerating tfhe with sorted bootstrapping techniques, in: International Conference on the Theory and Application of Cryptology and Information Security, Springer, 2025, pp. 68–100. doi:10.1007/978-981-95-5122-4_3. [8] B. Xiang, J. Zhang, Y. Deng, Y. Dai, D. Feng, Fast blind rotation for bootstrapping fhes, in: Annual International Cryptology Conference, Springer, 2023, pp. 3–36. doi:10.1007/978-3-031-38551-3_1. [9] I. Chillotti, D. Ligier, J.-B. Orfila, S. Tap, Improved programmable bootstrapping with larger precision and efficient arithmetic circuits for tfhe, in: International Conference on the Theory and Application of 15
Cryptology and Information Security, Springer, 2021, pp. 670–699. doi: 10.1007/978-3-030-92078-4_23. [10] Zama, Concrete: TFHE Compiler that converts python programs into FHE equivalent, https://github.com/zama-ai/concrete (2022). [11] Zama, Concrete ML: a privacy-preserving machine learning library using fully homomorphic encryption for data scientists, https://github. com/zama-ai/concrete-ml (2022). [12] Zama, TFHE-rs: A Pure Rust Implementation of the TFHE Scheme for Boolean and Integer Arithmetics Over Encrypted Data, https:// github.com/zama-ai/tfhe-rs (2022). [13] C. Gouert, D. Mouris, N. G. Tsoutsos, Helm: Navigating homomorphic encryption through gates and lookup tables, IEEE Transactions on Information Forensics and Security (2025). doi:10.1109/TIFS.2025. 3544066. [14] B. Chaturvedi, A. Chatterjee, A. Chattopadhyay, D. Mukhopadhyay, Bolt: Bootstrapping-aware logic resynthesis and technology mapping for efficient tfhe circuits, Cryptology ePrint Archive (2026). [15] F. S. Taşel, A. N. Saran, Improved arithmetic efficiency in tfhe through gate-level optimizations: Fs taşel, an saran, The Journal of Supercomputing 81 (18) (2025) 1633. doi:10.1007/s11227-025-08107-8. [16] F. Boemer, S. Kim, G. Seifu, F. D. de Souza, V. Gopal, et al., Intel HEXL (release 1.2), https://github.com/intel/hexl (september 2021). [17] D. Micciancio, Y. Polyakov, Bootstrapping in fhew-like cryptosystems, in: Proceedings of the 9th on Workshop on Encrypted Computing & Applied Homomorphic Cryptography, 2021, pp. 17–28. doi:10.1145/ 3474366.3486924.
16