Homomorphic Quantization Method

Updated 15 November 2025

Homomorphic quantization is a technique that maps high-precision data to a compact, low-bit format while remaining compatible with homomorphic encryption operations.
It employs clipping, dithered quantization, and batching strategies to control error growth and maintain computational integrity during encrypted arithmetic.
This method enhances privacy-preserving federated learning, encrypted inference, and secure control by mitigating error expansion and optimizing computation efficiency.

Homomorphic quantization refers to the family of algorithmic strategies that perform quantization—mapping high-precision real values to a compact, low-bit representation—in a manner that is specifically compatible with homomorphic encryption (HE) operations. This methodological integration enables arithmetic and aggregation over encrypted data without exposing sensitive information, while also addressing the efficiency bottlenecks in secure computation. Homomorphic quantization is central to efficient, privacy-preserving distributed learning, federated learning, encrypted machine learning inference, and encrypted control. Modern variants further exploit the quantization noise or structure to optimize noise growth, reduce ciphertext expansion, or provide robustness guarantees.

1. Mathematical Foundations and Error Modeling

The technical core of homomorphic quantization is to structure quantization such that all subsequent ciphertext manipulations (especially aggregation and multiplication) are correct modulo the introduced quantization error, and that the combined error remains bounded or can even provide cryptographic hardness.

A canonical model proceeds as follows. Let $g \in \mathbb{R}^d$ denote a vector to be securely shared or aggregated.

Clipping is applied to confine each coordinate to a bounded interval $[-C, C]$ :

$\hat{g} = \frac{g}{\max(1, \|g\|_\infty / C)}\,.$

Quantization uses a $b$ -bit quantizer $Q_b$ mapping $[\! -C, C] \to \Delta \cdot \mathbb{Z}$ , with step size $\Delta = 2C/2^b$ .
Half-dithered quantization introduces a random dither $u \sim \mathcal{U}(-\Delta/2, \Delta/2)$ , setting

$Q_b(\hat{g}_j) = \Delta \cdot \mathrm{round}\left( \frac{\hat{g}_j + u}{\Delta} \right)\,,$

for each coordinate $j$ . The quantization noise $\epsilon = Q_b(\hat{g}) - \hat{g}$ is characterized by

$\epsilon_j = e'_j + u,\quad e'_j \sim \mathcal{U}(-\Delta/2, \Delta/2),\quad E[\epsilon_j]=0, \quad \operatorname{Var}(\epsilon_j)\leq \Delta^2/12.$

This quantization output is then embedded in the plaintext space of an HE scheme, often through affine scaling, so that all elements fit within the HE message bounds. The randomness from quantization plays a central role in both correctness and cryptographic security.

2. Homomorphic Encryption Schemes and Quantized Inputs

Lattice-based Learning With Errors (LWE) mechanisms and various leveled HE constructions require mapping quantized, integer (or fixed-point rational) plaintexts to the modulus domain $\mathbb{Z}_q$ . For the LWE-type construction:

Secret key $s\in \mathbb{Z}_q^n$ , public matrix $A \in \mathbb{Z}_q^{m \times n}$ , quantizer $Q_b$ as above, scale $\gamma = q/(2C)$ .
Encryption:

$\mathrm{Enc}_s(g) = A s + \gamma Q_b(g) \in \mathbb{Z}_q^m\,.$

Decryption:

$\mathrm{Dec}_s(c) = \gamma^{-1} (c - A s) = Q_b(g).$

This ensures decryption recovers $g$ up to the quantization noise, which is unbiased and bounded.

A critical innovation, exemplified by "Learning with Gradients" (Yan et al., 2 Feb 2024), is the omission of the conventional LWE error term: the quantization noise $\epsilon$ itself provides sufficient hardness for Decision-LWE, and because it does not accumulate additively during ciphertext aggregation, the classical error expansion barrier is eliminated—allowing for arbitrarily many noisy sums as long as the quantization error remains controlled.

3. Architecture and Algorithmic Workflows

Homomorphic quantization schemes are instantiated via explicit workflows on both the client and server (or aggregator) sides.

Client-side pseudocode (as in (Yan et al., 2 Feb 2024)):

Receive and decrypt previous global ciphertext; reconstruct the quantized aggregate.
Update the local model parameters.
Compute fresh gradient $g^{(i)}$ .
Clip: $\hat{g}^{(i)} = \mathrm{clip}(g^{(i)}, C)$ .
Sample random dither $u$ , quantize: $Q_b(\hat{g}^{(i)})$ .
Encrypt: $c^{(i)} = A s^{(i)} + \gamma Q_b(\hat{g}^{(i)})$ .
Send $c^{(i)}$ to the server.

Server-side aggregation:

Receive $\{ c^{(i)} \}_{i=1}^N$ .
Aggregate: $c_\textrm{total} = \sum_i c^{(i)}$ .
Broadcast $c_\textrm{total}$ to all clients.

Any client can perform decryption of the aggregate with knowledge of the combined key $s_\mathrm{sum} = \sum_i s^{(i)}$ . The decryption process reconstructs the sum of quantized gradients modulo quantization noise, without further noise expansion.

Other works adapt this general pattern to, e.g., packed or batched representations in federated XGBoost (Xu et al., 2021) or CKKS-based neural network training and inference, leveraging quantization to amortize or compress ciphertext operations.

4. Error Expansion, Robustness, and Security

A central challenge in LWE-based HE is error expansion: in classical schemes, each encryption injects an independent "noise" vector ( $e$ ), whose norm grows as $O(\sqrt{N})$ under $N$ -fold summation, leading to decryption failure if not periodically refreshed. Homomorphic quantization as in (Yan et al., 2 Feb 2024) circumvents this by relying solely on deterministic quantization noise, ensuring that error terms cancel upon homomorphic summation, with only the zero-mean quantization residual remaining. This is formalized as:

$c_\mathrm{total} = A(\sum_i s^{(i)}) + \gamma \sum_i Q_b(g^{(i)}) \implies \mathrm{Dec}_{s_\mathrm{sum}}(c_\mathrm{total}) = \sum_i Q_b(g^{(i)}) = \sum_i g^{(i)} + \sum_i \epsilon^{(i)}$

with $E[\epsilon^{(i)}]=0$ and variance controlled by the quantizer.

Security under this approach is based on the standard LWE assumption. Provided the ciphertext modulus $q$ and bit-width $b$ satisfy $q/2^{b+1} \geq 2 n^{1/2+\delta} m$ , the LWE instance with uniform error is at least as hard as standard LWE with Gaussian error, yielding IND-CPA security.

5. Practical Implementations and Performance

Homomorphic quantization methods have been implemented in several domains, notably:

Federated deep learning (Yan et al., 2 Feb 2024): Enables quantum-safe aggregation of neural gradients from large numbers of clients without error expansion, supports high-precision learning modulo small quantization error (variance $\leq C^2/2^{2b-2}$ ).
Packed batch encoding for decision tree boosting (Xu et al., 2021): Jointly quantizes multiple statistics (e.g., first- and second-order derivatives) into a single integer representation, yielding a $2\times$ reduction in ciphertext count and homomorphic additions, and $44\%$ reduced runtime with negligible performance loss.
Neural network quantization (Legiest et al., 2023, Xu et al., 29 Jan 2024): Aggressive quantization-aware training (QAT) can minimize the final integer width of a DNN evaluated under BFV/CKKS, permitting aggressive compression of ciphertext modulus chains and up to $80\%$ inference speedup for MNIST, with $<1\%$ accuracy drop at 4-bit quantization. In HEQuant (Xu et al., 29 Jan 2024), intra-coefficient packing and tiling achieve end-to-end communication and latency reductions of $3.5$– $23.4\times$ and $3.0$– $9.3\times$ respectively over standard HE protocols at $b=2$ .
Privacy-preserving control (Marcantoni et al., 2022, Feng et al., 12 Apr 2025): Mixed uniform-logarithmic ("MULQ") quantizers enable sector-bounded quantization for encrypted feedback systems, guaranteeing closed-loop asymptotic stability and tunable quantization error.

Performance trade-offs typically manifest between quantization bit-width (accuracy/error), ciphertext modulus parameters (security and correctness), and communication/computation cost. Aggressive quantization exploits the intrinsic robustness of modern ML models to low-precision arithmetic while preserving HE security margins.

6. Extensions, Variants, and Theoretical Properties

Recent research includes several notable architectural or theoretical refinements:

Batch-encoding/batching: Encodes multiple values within a single integer (or polynomial), utilizing reserved bits for overflow detection (Xu et al., 2021), and reducing communication by $50\%$ .
Dithered quantization: Stochastic dither randomizes quantization artifacts, ensuring uniform error distribution and security hardness (Yan et al., 2 Feb 2024).
Mixed uniform-logarithmic quantizers (MULQ): As in (Marcantoni et al., 2022), achieve quantization that is both fine (uniform) within a dynamic range and logarithmic across scales, ensuring sector-bounded error properties and facilitating stable closed-loop encrypted control.
Error bounds and algorithmic tuning: Bit-width, clipping thresholds, and modulus choices are selected to upper bound quantization error, avoid overflow, and allow infinite-depth summation without error growth beyond security-determined thresholds.

These patterns can be abstracted as a design space in the following aspects:

Aspect	Design Option	Effect
Quantizer type	Uniform, dithered, MULQ	Error distribution, robustness
Bit-width $b$	2–8 bits	Error-accuracy trade-off
HE scheme	LWE/BFV/CKKS/Paillier	Field for plaintext/operation
Packing strategy	Batch, tile, multi-stat	Communication/computation
Security parameter	$q, n, m, b$	IND-CPA or IND-CCA security

7. Applications and Impact

Homomorphic quantization methods power a diverse set of privacy-preserving and efficient computation scenarios:

Federated learning: Supports training with quantum-safe guarantees and efficient communication, circumventing traditional trade-offs between privacy and learning dynamics (Yan et al., 2 Feb 2024).
Vertical federated XGBoost: Makes secure boosting practical at scale by batching derivatives (Xu et al., 2021).
Encrypted DNN inference: Enables fast, bandwidth-efficient evaluation of large models in settings where plaintext data cannot be revealed, with quantization-aware strategies eliminating the noise-growth bottleneck of prior HE-based inference (Xu et al., 29 Jan 2024, Legiest et al., 2023).
Networked encrypted control: Actuators and sensors exchange only quantized, encrypted signals, ensuring both privacy and convergence guarantees (Marcantoni et al., 2022, Feng et al., 12 Apr 2025).

Adoption of homomorphic quantization schemes in these domains enables new cryptographic learning and control protocols with better scalability, accuracy, and trust guarantees than prior HE techniques with conservative or operator-agnostic quantization.

In summary, the homomorphic quantization method strategically leverages quantization noise (whether uniform, dithered, or mixed) to achieve both cryptographic hardness and efficient arithmetic over ciphertexts, suppressing classical error expansion and enabling scalable, privacy-preserving statistical computation in federated learning, encrypted inference, and secure control (Yan et al., 2 Feb 2024, Xu et al., 2021, Marcantoni et al., 2022, Xu et al., 29 Jan 2024, Legiest et al., 2023, Feng et al., 12 Apr 2025). The field continues to evolve with new batching, packing, and quantizer architectures tailored to both HE primitives and ML/controls tasks, with quantization-aware design as a pivotal enabler of practical cryptographic computation.