Homomorphic encryption lets a server compute on data it cannot read. The cost is enormous memory traffic. Ciphertexts and the server-side "evaluation keys" that make computation possible are thousands of times larger than the data they protect, so accelerators run out of memory bandwidth long before they run out of arithmetic. Dense resistive crossbars are grids of memory cells at the crossings of row and column wires, and they can hold far more data per square millimetre than transistor-isolated memory. Their weakness is that cells leak current into each other through "sneak paths," so reads come back noisy. Homomorphic encryption already carries deliberate noise inside every ciphertext and key, and it budgets for that noise. The natural hope is that hardware noise could be charged to the same budget, and that read and write energy could be spent unevenly across bits, heavily on bits that matter and lightly on bits that sit below the cryptographic noise floor.
We argue that this hope is false for the most common accelerator data layout, and true for one specific, very large object. That object is the bootstrapping key of TFHE, a homomorphic scheme that works on 32- or 64-bit fixed-point "torus" numbers and refreshes ciphertext noise with a key tens of megabytes to gigabytes in size. This key is written once and read on every gate. Its low-order bits are, by construction, cryptographic noise, and they are partly discarded by the scheme's own digit decomposition. We propose to derive exactly how hardware errors in stored key bits enter TFHE's noise formula. That noise accounting then becomes the objective of a significance-aware allocation. The allocation decides, bit-plane by bit-plane, whether each bit is dropped, stored in a cheap selector-less crossbar with a chosen number of repeated reads, or stored in a robust transistor-isolated cell.
Core Claim
A hardware error only harms homomorphic computation according to its magnitude after it is mapped into the plaintext-plus-noise that decryption sees, and that mapping depends on data representation.
Consider first representations where every stored value is a residue modulo a word-sized prime (the residue number system used by CKKS and BFV accelerators), or a value in the number-theoretic-transform domain. There, a single flipped bit, even the lowest, turns into a pseudorandom error across the full ciphertext modulus once it is recombined or inverse-transformed. Bit significance is therefore meaningless, and uniform protection is required.
In TFHE's positional torus representation, stored with a floating-point Fourier transform as practical implementations do, the situation is different. A flip in bit $i$ of a key coefficient adds an error of magnitude $2^{i-w}$, where $w$ is the word width in bits. The Fourier transform approximately preserves error energy, so this error enters the blind-rotation noise exactly where the key's own Gaussian noise does. The standard blind-rotation output variance then becomes
$$V_{\text{out}} \approx n\,\ell\,(k+1)\,N\,\frac{B^2}{12}\left(\sigma_{\text{bsk}}^2 + \sigma_{\text{hw}}^2\right) + V_{\text{other}}, \qquad \sigma_{\text{hw}}^2 = \sum_{i} p_i\,4^{\,i-w}.$$
Here $n$ is the input LWE dimension, $\ell$ and $B$ are the number and base of decomposition digits, $k$ and $N$ are the GLWE dimension and ring degree, $\sigma_{\text{bsk}}^2$ is the key's cryptographic noise variance, $p_i$ is the per-read flip probability of bit-plane $i$, and $V_{\text{other}}$ collects terms that do not depend on the stored key. The form comes from the standard external-product analysis: each stored-key error is multiplied by a decomposed digit of variance about $B^2/12$ and summed over $n\ell(k+1)N$ products. Given a failure-probability target, a parameter set leaves slack $V_{\text{budget}}$ between its actual $V_{\text{out}}$ and the decryption threshold. The design problem is then
$$\min_{x_i} \sum_i E_i(x_i) \quad \text{s.t.} \quad \sum_i p_i(x_i)\,4^{\,i-w} \le \frac{V_{\text{budget}}}{n\ell(k+1)NB^2/12},$$
where $x_i$ is the storage choice for bit-plane $i$: dropped ($p_i = 1/2$, zero energy and area), passive crossbar with $r$ reads, or transistor-isolated cell. $E_i$ is its energy-and-area cost. This is the generalized water-filling problem of Generalized Water-Filling for Source-Aware Energy-Efficient SRAMs, which solved it for SRAM bitline swings on unencrypted images. It is posed here for a cryptographic noise budget instead of image mean squared error, and over a discrete menu of cell types and read counts instead of a continuous voltage.
Why the obvious version fails
The obvious intersection of these directions is significance-aware undervolting of CKKS ciphertexts in RRAM processing-in-memory. It builds on MemFHE, which runs full homomorphic arithmetic and bootstrapping inside RRAM crossbars and asserts that RRAM noise "can be modeled and absorbed by FHE's own noise-handling parameters," while modelling neither sneak paths nor bit-level errors. The research file does not say which representation MemFHE uses.
The contradiction is direct. If the data is in residue or transform form, an uncorrelated one-bit error in one residue is not a small additive perturbation. Both rescaling and inverse transforms multiply it by a large modular inverse. Our first experiment tests this claim cheaply and head-on. Its likely negative result is a contribution in itself: it constrains which accelerator data may live in unprotected dense arrays.
The skeptic's point, recorded in the file, that ciphertext bits are pseudorandom so significance is meaningless, is thus correct for residue data. It is wrong for positional torus data, where the low bits are pseudorandom but are also, numerically, below the noise that decryption already tolerates.
Research Program
The work has three parts.
The first part is an error-propagation map. For CKKS/BFV in residue and transform form, and for TFHE in torus coefficient and Fourier form, we will inject bit errors at controlled positions and rates into each stored object: ciphertexts, relinearization and key-switching keys, and bootstrapping keys. We will then measure the resulting decrypted-noise variance and tail against the analytical prediction. The output is a per-object, per-bit tolerance table. It tells an architect which data can go on cheap dense arrays at all.
The second part is a realistic crossbar error model for the key store. Sneak-path errors are data-dependent and spatially correlated, not independent coin flips. We will use the sneak-path read channel and multi-read single-bit quantizers of Quantization Design for Resistive Memories With Multiple Reads, which showed that more reads beat more ADC resolution: one-bit sensing with three reads approaches a 3-bit quantizer. The number of reads $r$ is therefore the natural per-bit-plane energy knob. We will also include belief-propagation sneak-path cancellation from Belief Propagation for Sneak-Path Cancellation as a stronger read option. Write-side noise will be handled with per-bit-plane verify budgets, in the spirit of U-SWIM. U-SWIM chose which neural-network weights to write-verify using Hessian sensitivity. We instead choose by the noise-formula coefficient $4^{i-w}$, which is known in closed form, so no Hessian is needed.
The open scientific question is whether correlated sneak-path errors add variance the way the independent-noise formula assumes. If correlation fattens the output tail, the budget must be shrunk accordingly, and we will measure by how much.
The third part is the hybrid array and its allocator. The discrete water-filling solution, computed with a greedy Levin–Campello procedure as in the SRAM work, assigns top bit-planes to transistor-isolated one-transistor-one-resistor cells. Transistor Row Isolation for Memristive Arrays shows these cells remove sneak paths at an area cost. Middle bit-planes go to passive crossbars with $r_i$ reads, and bottom planes are not stored. This is the crossbar analogue of Significance Driven Hybrid 8T-6T SRAM, which stored the top 3–4 weight bits in robust cells for a 30.91% access-power cut on MNIST. The difference is that our significance ranking is set by a cryptographic failure bound rather than classification accuracy. Energy, latency and area will be estimated with MICSim, which models RRAM arrays and reports energy within 10% of trace-based estimates.
The allocator will be placed inside a near-memory TFHE pipeline patterned on APACHE. APACHE supports TFHE operators with a 315,000× reduction in their I/O bandwidth, keeps the key close to compute, and reports 4597× faster HE³DB encrypted-database queries than CPU.
We will also check security explicitly. Errors in a server-held evaluation key do not weaken the LWE assumption. However, data-dependent sneak-path errors could make decryption failures correlate with secret-key bits, and failure-reaction attacks exploit exactly such correlations. We will test for any correlation between failure events and key bits.
Baselines
The naive reference is a passive crossbar key store with uniform single-read sensing at nominal voltage and no significance awareness. This shows how badly unmodified dense arrays fail, reported as measured output variance and extrapolated bootstrapping failure probability.
The strongest existing reliability approach is uniform protection. Every stored key bit gets the same treatment, either one-transistor-one-resistor cells or passive cells with enough uniform repeated reads to meet the failure target. This is what an architect would build today. No reported result was found on Lacuna for TFHE bootstrapping-key storage energy or area on crossbars. For the system context, the strongest reported numbers are APACHE's 4597× HE³DB speedup over CPU APACHE and MemFHE's 265× arithmetic speedup over GPU MemFHE. Our proposal does not aim to beat those speedups. It aims to reduce the key-store energy and area inside such a pipeline without changing its throughput.
The key ablation is truncate-then-protect. The bottom bit-planes that the noise budget allows are dropped, and all remaining planes get uniform robust storage. This isolates whether the graded middle tier of cheap cells with varied read counts adds anything beyond precision reduction.
A further ablation replaces our closed-form noise weights with measured per-bit sensitivity, U-SWIM style, to test whether the analytical map loses anything.
All variants share the same TFHE parameter sets, the same failure target, the same MICSim technology node and array sizes, the same sneak-path channel model, and the same allocator search budget. Beating a baseline means lower key-store read energy per bootstrap, or lower array area per key bit, at an equal or lower measured output variance and tail. A result counts only if it holds under the correlated sneak-path model and not just under independent flips.
Why not just…?
Why not just protect everything and accept the energy? Uniform protection is always correct, and if key reads are a small fraction of bootstrap energy, it is good enough. This is a real threat. We will report the key store's share of total bootstrap energy in the simulated pipeline before claiming any system-level gain. The file shows that key traffic dominates in-memory FHE designs: APACHE cites key-switching I/O approaching 10,000 GB/s. That motivates the question but does not settle it for TFHE bootstrapping keys specifically.
Why not just truncate the key to fewer bits and store the rest reliably? This is the most plausible competitor. It likely captures most of the density gain, because the water-filling optimum already sets many bottom planes to "drop." We therefore made truncation a corner case of the allocator rather than a rival. The truncate-then-protect ablation will show whether the graded middle tier earns its peripheral cost. The SRAM results suggest the peripheral cost can erode savings when granularity is too fine. If the graded tier does not beat truncation, the paper's result becomes the noise map and the correlated-error correction to the budget, and we will say so.
Why not just pick TFHE parameters with more noise slack and run the whole crossbar cheaply? Larger decomposition depth or dimension buys slack but multiplies compute and key size, which enlarges the very store we are trying to shrink. We will include a reparameterized-uniform baseline: the cheapest parameter set whose slack absorbs uniform cheap reads. We will compare total energy and area, not key-store energy alone.
Why not just use MemFHE's claim and absorb RRAM noise into CKKS? The first experiment tests this directly. If single residue errors do stay small, our constraint on residue-form data is wrong and the design space widens. If they randomize the ciphertext, as the modular-inverse argument predicts, absorption requires error-free residue storage.
Proposed Experiments
The first check is the CKKS/BFV residue and transform-domain injection study, using MNIST-scale encrypted inference in the style of CryptoNets. It is decisive if a single low-bit residue error drives decryption error to near-uniform.
The second check compares measured against predicted TFHE blind-rotation variance under independent flips and under the Mei et al. sneak-path channel, across bit-planes and read counts. The predicted $4^{i-w}$ scaling should hold for independent errors. The size of any correlated-error excess sets the safety factor.
The third check sweeps the allocator against all baselines at fixed failure targets. The workloads are TFHE programmable bootstrapping microbenchmarks, TFHE-evaluated MNIST inference, and HE³DB-style queries, reporting key-store energy per bootstrap, array area per stored key bit, latency, and output-noise tail.
The fourth check is the secret-correlation test on failure events. The proposal succeeds if graded allocation beats truncate-then-protect by a clear margin at equal measured tail under correlated errors, and if no key-bit correlation appears in failures.
References
- Generalized Water-filling for Source-Aware Energy-Efficient SRAMs
- MemFHE: End-to-end Computing with Fully Homomorphic Encryption in Memory
- Quantization Design for Resistive Memories With Multiple Reads
- Belief Propagation Based Joint Detection and Decoding for Resistive Random Access Memories
- U-SWIM: Universal Selective Write-Verify for Computing-in-Memory Neural Accelerators
- Long-term and short-term memory networks based on forgetting memristors
- Significance driven hybrid 8T-6T SRAM for energy-efficient synaptic storage in artificial neural networks
- MICSim: A Modular Simulator for Mixed-signal Compute-in-Memory based AI Accelerator
- APACHE: A Processing-Near-Memory Architecture for Multi-Scheme Fully Homomorphic Encryption
- CryptoNets: Applying Neural Networks to Encrypted Data with High Throughput and Accuracy