Cryptographic frameworks like Fully Homomorphic Encryption (FHE), Secure Multi-Party Computation (SMC), and zero-knowledge proofs (zk-SNARKs) offer powerful mathematical guarantees for data privacy and verification. However, they share a fundamental constraint: their underlying primitives operate strictly over discrete algebraic structures, such as integers, finite fields, or rings. Conversely, modern analytical workloads—ranging from deep learning and signal processing to distributed optimization—rely inherently on continuous, real-valued data represented as floating-point numbers.
To bridge this gap, a major research direction focuses on transforming continuous real numbers into discrete cryptographic domains. By designing specialized quantization, scaling, and algebraic mapping strategies, researchers enable complex continuous algorithms to execute securely without sacrificing numerical precision or incurring prohibitive computational overhead.
The Core Mechanism: Fixed-Point Scaling
The foundational strategy for executing real-valued computations over integer-only cryptographic systems is fixed-point arithmetic. Instead of representing numbers with a dynamic exponent (as in standard floating-point representations), numbers are multiplied by a predetermined scaling factor $S$ and rounded to the nearest integer:
$$\bar{x} = \lfloor x \cdot S \rfloor$$
This simple transformation preserves linear operations perfectly. If two real numbers $x$ and $y$ are encoded as $\bar{x}$ and $\bar{y}$, their sum can be computed directly in the encrypted or shared domain because addition distributes over the scaling factor:
$$\bar{x} + \bar{y} = \lfloor x \cdot S \rfloor + \lfloor y \cdot S \rfloor \approx (x + y) \cdot S$$
In Cryptographically private support vector machines, Laur et al. used this fixed-point transformation to map continuous input data into a discrete integer space, balancing numerical precision with the constraints of secure multi-party computation primitives. This mechanism has since become a cornerstone for processing continuous data across diverse domains. For example, Penn et al. demonstrated in Extracting Mel-Frequency and Bark-Frequency Cepstral Coefficients from Encrypted Signals that continuous audio signals can be converted into integers via a fixed scaling factor, allowing speech feature extraction to occur entirely within integer-based homomorphic encryption schemes.
Similarly, in distributed optimization and federated learning, scaling factors allow continuous parameters to be safely manipulated by integer-based cryptographic backends. In Privacy-aware quadratic optimization using partially homomorphic encryption, Shoukry et al. applied fixed-point scaling to solve multi-agent optimization problems over the Paillier cryptosystem. To protect model updates in healthcare applications, Taiello et al. implemented uniform quantization in Enhancing Privacy in Federated Learning: Secure Aggregation for Real-World Healthcare Applications to map continuous floating-point model parameters into finite integer bit-ranges for secure aggregation.
Managing Multiplicative Scale and Overflows
While addition preserves the scaling factor $S$, multiplication compounds it. Multiplying two scaled numbers yields a product scaled by $S^2$:
$$\bar{x} \cdot \bar{y} = (x \cdot S) \cdot (y \cdot S) = (x \cdot y) \cdot S^2$$
Left unchecked, repeated multiplications cause the scaling factor—and the size of the integers—to grow exponentially. In finite fields or rings, this growth leads to catastrophic overflows or wraps around the modulus, destroying the mathematical integrity of the underlying algorithm.
As a result, tracking and managing the multiplicative scale is a core challenge. In Logistic regression over encrypted data from fully homomorphic encryption, Chen et al. emphasized that specialized encoding techniques must carefully align polynomial terms and manage scaling factors across iterations to bridge the gap between continuous statistical modeling and discrete homomorphic encryption.
For deep learning workloads where matrix multiplications dominate, managing this scale is vital for performance. In Towards End-to-End Private Automatic Speaker Recognition, Teixeira et al. employed fixed-point arithmetic to translate continuous neural network parameters and activations into integer-based replicated secret sharing protocols, enabling secure convolutions and statistical pooling. Similarly, Chen et al. developed a secret sharing-based matrix multiplication protocol in Secure Social Recommendation based on Secret Sharing that leverages fixed-point arithmetic to execute gradient-based optimization without the massive overhead of emulating floating-point logic cryptographically.
An alternative approach to pure fixed-point scaling is to emulate floating-point behavior by grouping values. In Answering Aggregation Queries in a Secure System Model, Ge et al. supported floating-point arithmetic in integer homomorphic schemes by grouping values into specific exponent ranges and normalizing their significant bits, allowing for the secure aggregation of double-precision numbers.
Handling Signs and Division
Standard finite fields natively represent non-negative integers modulo a prime $p$. To support real-world algorithms, the mapping must handle both negative numbers and division.
Signed Numbers in Finite Fields
To represent negative numbers, researchers typically split the algebraic ring or field into two halves, mapping negative values to the upper half of the field (i.e., treating a large field element $p - x$ as $-x$). In Efficient and secure multi-party computation protocol supporting deep learning, Zhang et al. refined Shamir Secret Sharing by mapping elements of a finite field to a ring of signed, fixed-point numbers, allowing neural networks to maintain positive and negative weights natively. Similarly, Lu et al. established systematic transformation mechanisms in Privacy preserving distributed optimization using homomorphic encryption to map signed real numbers to large integers, ensuring that gradient descent steps can move in both positive and negative directions within the encrypted domain.
The Challenge of Division
Division is notoriously difficult in secure computation because modular inverses in a finite field do not correspond to standard fractional division. Researchers circumvent this using two primary insights: deferring the division until after decryption, or using specialized algebraic properties.
In Encrypted Accelerated Least Squares Regression, Esperança et al. bypassed mid-computation division by scaling real values into large integers and tracking the scaling factors across iterations, effectively deferring the division step until the final data is decrypted by the user.
When division must happen within the secure domain, specialized protocols are required. In FORESEE: Fully Outsourced secuRe gEnome Study basEd on homomorphic Encryption, Dai et al. achieved exact division on encrypted data by mapping fractional results to unique integers in the ciphertext domain using Fermat’s Little Theorem, allowing the user to retrieve precise floating-point results via a pre-computed lookup table post-decryption. For reinforcement learning workloads, Sakuma et al. demonstrated in Privacy-preserving reinforcement learning that decimal-based learning rates and discount factors can be managed by scaling them to large integers and deploying a private division protocol to handle rescaling and normalization without exposing raw numerical data.
Broadening Applications: Coded Computing and Verification
The necessity of mapping real numbers to finite fields extends beyond privacy-preserving model execution to distributed fault tolerance and computational verification.
Coded Computing
In distributed learning, algebraic coding techniques are used to inject redundancy and mitigate the impact of slow "straggler" nodes. However, these codes require finite field arithmetic. In Coding for Straggler Mitigation in Federated Learning, Kumar et al. mapped real-valued gradients to fixed-point representations to ensure compatibility with integer-based one-time padding and gradient coding. To scale collaborative learning to dozens of participants, Guler et al. developed A Scalable Approach for Privacy-Preserving Collaborative Machine Learning, which quantizes real-valued data into integers within a finite field to enable modular arithmetic for algebraic secret sharing. This approach was expanded by Zhu et al. in Generalized Lagrange Coded Computing: A Flexible Computation-Communication Tradeoff, where real-valued gradients and weights are mapped into finite field integers through a quantization scheme, allowing modular arithmetic to secure distributed computing while maintaining numerical accuracy via inverse mapping.
Verification and Proof Systems
When outsourcing computations to an untrusted cloud, data owners must verify that the results are accurate. Cryptographic proof systems like zk-SNARKs operate over finite fields, requiring a similar real-to-integer transformation. In Cheap Checking for Cloud Computing: Statistical Analysis via Annotated Data Streams, Hickey et al. mapped real-valued computations into finite fields by scaling floating-point numbers by a large constant and rounding them to integers, allowing a verifier to check the results of statistical tasks like PCA and OLS while strictly bounding the permissible margin of error. This mechanism is also vital for verifying decision processes; Jiang et al. introduced Privacy-Preserving UCB Decision Process Verification via zk-SNARKs, which maps floating-point parameters and rewards to finite field integers to allow an AI system to prove it made a correct decision without revealing proprietary parameters.
Inverting the Paradigm for Hardware Acceleration
While most work focuses on mapping continuous data to discrete fields, the paradigm can be inverted to leverage hardware acceleration. Modern GPUs are heavily optimized for floating-point math rather than the massive integer arithmetic required by cryptography.
Standard Pipeline:
[Continuous Real Data] ---> (Fixed-Point Scaling) ---> [Cryptographic Integers/Fields]
GPU-Outsourced Pipeline (Goten):
[Cryptographic Integers] ---> (Float53 Embedding) ---> [GPU Floating-Point Hardware]
In Goten: GPU-Outsourcing Trusted Execution of Neural Network Training, Ng et al. flipped the standard mapping process. They mapped large integers from cryptographic finite fields into high-precision floating-point representations—specifically embedding 53-bit integers within 64-bit double-precision floats. This prevents overflow and maintains cryptographic integrity while allowing untrusted GPUs to accelerate secure neural network training.
Key Foundational Work
Cryptographically private support vector machines (2006) — contributed 1 concept elements to this direction.
Answering Aggregation Queries in a Secure System Model (2007) — contributed 1 concept elements to this direction.