Papers
Topics
Authors
Recent
Search
2000 character limit reached

Multi-Input Lookup Table Protocol

Updated 7 July 2026
  • Multi-input lookup table protocols transform structured inputs into precomputed indices, reducing online computation in neural, privacy-preserving, quantum, and FPGA designs.
  • They combine offline preprocessing—via centroid learning, bit-level decomposition, or secret sharing—with fast online lookup to replace repeated arithmetic calculations.
  • Optimized implementations balance memory, latency, and fidelity tradeoffs, achieving significant improvements in speed, model size, and energy efficiency across diverse applications.

Searching arXiv for papers relevant to multi-input lookup table protocols across ML, privacy-preserving computation, quantum lookup architectures, and FPGA LUT mapping. In the cited literature, a multi-input lookup table protocol is not a single standardized construction but a recurring computational pattern: multiple input components are transformed into an address, index, centroid identifier, or routing configuration, and a precomputed value is retrieved instead of recomputing the target function online. This pattern appears in learned neural inference systems that replace linear arithmetic with centroid lookup, in privacy-preserving machine learning protocols that retrieve secret-shared nonlinear values, in fault-tolerant quantum circuits that implement kk-bit addressable data access, in FPGA technology mapping where Boolean networks are covered by kk-input LUTs, and in multiplier-less neural inference schemes that partition bit-level or spatial inputs into table addresses (Tang et al., 2023, Saleem et al., 2024, Häner et al., 2022, Zhu et al., 2024, Yu, 15 Jul 2025, Lam et al., 2022, Wu, 2019).

1. Conceptual scope and recurring structure

Across these formulations, lookup-table evaluation typically separates an offline or preprocessing stage from an online execution stage. In LUT-NN, representative input patterns are learned as centroids and operator outputs for those centroids are precomputed into tables; in Hawk and Tabula, tables are generated offline and queried online under additive secret sharing; in quantum lookup circuits, data strings d0,…,dK−1d_0,\dots,d_{K-1} specify a table function f:{0,1}k→{0,1}mf:\{0,1\}^k\to\{0,1\}^m that is later queried by an address register; and in TableNet, affine layers are decomposed into table evaluations plus additions and shifts (Tang et al., 2023, Saleem et al., 2024, Lam et al., 2022, Häner et al., 2022, Wu, 2019).

A concise way to compare these usages is to distinguish what counts as the “input,” what is precomputed, and what the lookup returns.

Domain Multi-input object Retrieved result
DNN approximation sub-vectors or packed token groups precomputed operator contributions
PPML secret-shared nonlinear input or noisy masked key secret shares of f(x)f(x)
Quantum lookup kk-bit address register mm-bit data word
FPGA mapping Boolean support of up to kk inputs LUT-implementable logic function
Multiplier-less NN inference bit chunks, bitplanes, or spatial patches partial affine output

This suggests that “multi-input” has field-specific meanings. In neural approximation, it usually denotes structured high-dimensional inputs decomposed into sub-vectors or groups. In cryptography, it refers either to a secret-shared function argument or to protocol variants for handling functions that depend on several coordinates. In quantum computing, it denotes explicit address width kk. In FPGA design, it refers to the bounded fan-in of a physical LUT, typically 4 to 6 inputs (Tang et al., 2023, Saleem et al., 2024, Zhu et al., 2024, Yu, 15 Jul 2025).

2. Address formation, decomposition, and retrieval semantics

The central design problem is how to turn a structured input into a compact lookup address without losing too much fidelity, security, or implementability. LUT-NN adopts a product-quantization-style decomposition in which an input vector a∈RDa\in\mathbb{R}^D is split into CC sub-vectors of length VV, with D=C⋅VD=C\cdot V, and each sub-vector aca^c is assigned to a centroid from a codebook Pc={P0c,…,PK−1c}P^c=\{P_0^c,\dots,P_{K-1}^c\}. The encoding is nearest-centroid assignment,

gc(ac)=arg mink∥ac−Pkc∥2,g^c(a^c)=\underset{k}{\mathrm{arg\ min}}\left\|a^c-P_k^c\right\|^2,

and the full multiplication is approximated by

a⋅b≈∑cgc(ac)⋅hc(bc),a\cdot b \approx \sum_c g^c(a^c)\cdot h^c(b^c),

where hc(bc)h^c(b^c) stores the precomputed dot products between centroids and weight sub-vectors. The paper emphasizes that with KK centroids per codebook and CC codebooks, the representation capacity is KCK^C, while the memory cost is only K×CK\times C (Tang et al., 2023).

TableNet uses a more explicit bit-level decomposition. If the input set II needs β(I)\beta(I) bits and the output set OO needs β(O)\beta(O) bits, a direct table requires 2β(I)β(O)2^{\beta(I)}\beta(O) bits. To control the exponential growth, the input bits are partitioned into kk chunks with ∑imi=β(I)\sum_i m_i=\beta(I); each chunk indexes its own LUT of size 2miβ(O)2^{m_i}\beta(O) bits, and partial outputs are summed. The same principle is applied to affine maps Wx+bWx+b, fixed-point bitplanes, floating-point mantissa/exponent decomposition, convolutional patches, signed numbers, and stochastic rounding, so that multiple input fragments jointly determine one or more LUT queries whose outputs are recombined additively (Wu, 2019).

Vec-LUT changes the granularity of the address rather than the approximation model. For mixed-precision GEMM W×A=O\mathbf{W}\times\mathbf{A}=\mathbf{O}, with W∈RM×K\mathbf{W}\in\mathbb{R}^{M\times K}, A∈RK×N\mathbf{A}\in\mathbb{R}^{K\times N}, and grouped weights of size gg, the unified LUT has shape

T∈RK/g×3g×N.\mathbf{T}\in\mathbb{R}^{K/g\times 3^g\times N}.

Each packed weight index W[m,k]\mathbf{W}[m,k] addresses a vector of NN precomputed results, yielding the 1→N1\rightarrow N rule

O[m,n]=∑k=1K/gT[k,W[m,k],n].\mathbf{O}[m,n]=\sum_{k=1}^{K/g}\mathbf{T}[k,\mathbf{W}[m,k],n].

Here the multi-input character arises from grouping gg ternary weights into a single decimal index and retrieving a token-parallel vector rather than a scalar (Li et al., 6 Dec 2025).

Quantum lookup protocols make address semantics explicit. The classical table function f:{0,1}k→{0,1}mf:\{0,1\}^k\to\{0,1\}^m is implemented reversibly as

∣x⟩∣y⟩↦∣x⟩∣y⊕f(x)⟩.|x\rangle|y\rangle \mapsto |x\rangle|y\oplus f(x)\rangle.

The unified quantum architecture similarly realizes

Ox⃗∑i∈[N]αi∣i⟩∣0⟩=∑i∈[N]αi∣i⟩∣xi⟩,O_{\vec{x}}\sum_{i\in[N]}\alpha_i|i\rangle|0\rangle=\sum_{i\in[N]}\alpha_i|i\rangle|x_i\rangle,

but parameterizes the routing and retrieval structure through memory partition size λ\lambda and CNOT-subtree size γ\gamma, so the address is consumed by a hierarchical routing network rather than by a classical table index alone (Häner et al., 2022, Zhu et al., 2024).

3. Learned and approximate protocols for neural inference

In neural inference, the multi-input lookup-table protocol is principally a strategy for replacing arithmetic with indexed retrieval while preserving task accuracy. LUT-NN is described as the first system to empower inference by table lookup, and its central claim is that prior PQ-style approximations fail on deep networks because they optimize quantization distance rather than end-task loss. Its answer is differentiable centroid learning through backpropagation, with three explicit approximation controls: soft-PQ for differentiable centroid assignment, learned temperature for layer-specific softmax sharpness, and quantization-aware training for scalar-quantized lookup tables, typically INT8 (Tang et al., 2023).

The training-time relaxation replaces the non-differentiable arg⁡min⁡\arg\min with

g~c(ac)=softmax ⁣(−∥ac−Pkc∥2/t),\tilde g^c(a^c)=\mathrm{softmax}\!\left(-\|a^c-P_k^c\|^2/t\right),

and uses a straight-through-style formulation so that the forward pass matches hard inference behavior while the backward pass allows gradients to flow to centroids. The paper states that centroids are initialized with k-means from a sampled training subset, and that a separate temperature is learned per layer because approximation error compounds across many layers (Tang et al., 2023).

At inference, the protocol reduces to two stages: closest centroid search and table read plus accumulation. The hardware-aware aspect is not incidental. LUT-NN introduces centroid-stationary computation, intra-codebook parallelism, SIMD shuffle-based table lookup using pshfb on x86 and tbl on ARM, and mixed-precision accumulation that starts in INT16 and widens to INT32. On 128-bit SIMD, the shuffle-based design allows 16 lookups simultaneously. Reported savings include FLOPs reduction 5.7×5.7\times to 16×16\times, model size reduction 3.4×3.4\times to 7×7\times, latency reduction 1.3×1.3\times to 6.8×6.8\times, memory reduction 1.4×1.4\times to 6.5×6.5\times, and power reduction 15%15\% to 41.7%41.7\%, while accuracy improves by 66%66\% to 92%92\% over directly applying Maddness and remains close to original models (Tang et al., 2023).

Vec-LUT addresses a different bottleneck: existing scalar LUT kernels underutilize memory bandwidth during parallel inference. The paper identifies the failure mode as the scalar 1→11\rightarrow 1 paradigm, in which each token builds a separate LUT and performs separate non-contiguous table accesses. Vec-LUT instead constructs a unified LUT across all NN tokens and performs a single 1→N1\rightarrow N lookup per index. The associated implementation includes Vector LUT-Centric Tensor Layout, Cache-Aware Streamed Lookup, INT16-INT32 hierarchical accumulation, and topological precomputing that reduces operations from 2×3g−1g2\times 3^{g-1}g to 3g3^g, giving a speedup of 2g3\frac{2g}{3} (Li et al., 6 Dec 2025).

The paper reports that memory bandwidth utilization in parallel inference can drop to ≤40%\le 40\% under scalar LUT execution. With vector LUT, lookup time becomes marginal in the reported breakdown for HF BitNet 3B prefilling: Precompute 1.85%1.85\%, Accumulate 65.24%65.24\%, Lookup 0.59%0.59\%, Others 32.32%32.32\%. End-to-end gains reach up to 4.2×4.2\times, and on AWS Graviton 3 the I2 configuration achieves 273.5 tokens/s, including 152.6 tokens/s prefilling and 120.9 tokens/s decoding (Li et al., 6 Dec 2025).

TableNet represents an earlier multiplier-less formulation. Rather than learning centroids, it decomposes trained inference into LUTs plus addition and bit-shifts, targeting dense layers and convolutions. The tradeoff is structural: larger LUTs reduce arithmetic, while smaller LUTs require more partitioning and therefore more LUT evaluations and additions. The paper emphasizes that similar performance can be obtained with a comparable memory footprint as a full precision deep neural network, but without the use of any multipliers (Wu, 2019).

4. Secure and privacy-preserving lookup protocols

In privacy-preserving machine learning, the lookup-table protocol is used primarily for nonlinear functions, because linear algebra under additive secret sharing is comparatively efficient while activations such as $\sigmoid$, $\relu$, $\drelu$, and $\softmax$ are expensive under garbled circuits or polynomial approximations. Tabula and Hawk both replace those nonlinear subroutines with secure lookup tables, but they make different security-efficiency tradeoffs (Lam et al., 2022, Saleem et al., 2024).

Tabula is a secure inference protocol for nonlinear activations in the two-party semi-honest setting. Its key observation is that aggressive quantization makes the activation domain small enough to tabulate. In preprocessing, for each nonlinear activation call, a quantization scale dd is chosen, a fresh secret ss is generated and additively shared, and a secure lookup table [T][T] is initialized so that

[T][s+x]=[F(x)].[T][s+x]=[F(x)].

Online execution consists of secure truncation, revealing only the masked index sx=xtrunc+ss_x=x_{\mathrm{trunc}}+s, performing the lookup, and rescaling (Lam et al., 2022).

The online communication cost is stated as twice the field bitlength because the parties exchange shares of one masked field element. With a 64-bit field, this is 128 bits, or 16 bytes per activation. The paper reports that for a single ReLU, Tabula uses between $280$-560×560\times less communication than garbled circuits in the abstract, and the detailed comparisons list 2.17 KB, 1.1 KB, and 0.562 KB for 32-bit, 16-bit, and 8-bit garbled circuits versus 16 B for Tabula. End-to-end, Tabula reduces inference communication by up to 9×9\times and achieves up to 50×50\times speedup, while focusing explicitly on online efficiency rather than preprocessing improvements (Lam et al., 2022).

Hawk extends secure lookup tables into privacy-preserving training and evaluation in a two-server model with non-colluding servers P0,P1P_0,P_1, using additive secret sharing over Zn\mathbb{Z}_n: x=⟨x⟩0+⟨x⟩1(modn).x=\langle x\rangle_0+\langle x\rangle_1 \pmod n. Its two protocols are ΠHawkSingle\Pi_{\text{HawkSingle}}, a one-time table-use protocol that is leakage-free or perfectly secure in the semi-honest model, and ΠHawkMulti\Pi_{\text{HawkMulti}}, a reusable-table protocol that leaks a privacy-preserving access pattern (Saleem et al., 2024).

HawkSingle uses fresh table-specific masks H(ki∥c)H(k_i\|c), random table permutations, and one-round online lookup. HawkMulti introduces elliptic-curve-based deterministic key derivation and a share-conversion subprotocol from Zn\mathbb{Z}_n to ZN\mathbb{Z}_N, then perturbs the input by geometric noise,

x^=x+γ,\hat x=x+\gamma,

to obtain access-pattern leakage that satisfies local ϵ\epsilon-dXd_{\mathcal X}-privacy with dX(x,x′)=∣x−x′∣d_{\mathcal X}(x,x')=|x-x'|. The leakage is the pseudorandom lookup key

L=κ=k0k1(x^G+s0cG+s1cG),\mathcal{L}=\kappa=k_0k_1(\hat xG+s_0^cG+s_1^cG),

which the paper interprets as essentially a histogram of accesses rather than raw plaintext values (Saleem et al., 2024).

The distinction between single-input and multi-input nonlinearities is especially visible in Hawk’s treatment of $\softmax$. Instead of a single huge multivariate table, Hawk uses two univariate tables—one for exe^x and one for $1/s$, where s=∑jexjs=\sum_j e^{x_j}—and then multiplies. This is the paper’s explicit method for handling a multi-input function without exponential-size multivariate LUTs (Saleem et al., 2024). A common misunderstanding is that secure lookup tables eliminate all tradeoffs relative to garbled circuits; the literature instead shows a layered set of tradeoffs involving offline storage, number of rounds, leakage model, and quantization precision (Lam et al., 2022, Saleem et al., 2024).

5. Quantum multi-input lookup architectures

In quantum computing, the multi-input lookup-table protocol is a reversible data-access primitive whose inputs are address qubits and whose outputs are data qubits. The 2022 lattice-surgery work studies a classical table function f:{0,1}k→{0,1}mf:\{0,1\}^k\to\{0,1\}^m under fault-tolerant surface-code constraints on a 2D grid. Its lookup operation is

∣x⟩∣y⟩↦∣x⟩∣y⊕f(x)⟩,|x\rangle|y\rangle \mapsto |x\rangle|y\oplus f(x)\rangle,

with a controlled version that applies the lookup only when a control qubit is active. The logical construction is the unary-iterate lookup of Babbush et al., reorganized around surface-code primitives such as multi-target CNOT, AND, AND†^\dagger, CCiX, delayed-choice CZ, remote ZZ and XZ measurements, cat-state fanout, and switch-board routing (Häner et al., 2022).

This construction gives exact resource formulas. For uncontrolled lookup, the number of AND gates is 2k−22^k-2 for k≥1k\ge 1, and because each AND costs four ∣T⟩|T\rangle states, the unary-iterate table lookup consumes

NTLT(k)=4(2k−2)=2k+2−8(k≥1).N^{\mathrm{TL}_T}(k)=4(2^k-2)=2^{k+2}-8 \qquad (k\ge 1).

The paper then derives logical-depth recurrences and 2D layout qubit counts, and introduces the zipper construction, which runs two lookup branches in parallel to trade more qubits for less critical depth (Häner et al., 2022).

The later unified architecture generalizes the landscape substantially. It implements quantum access to arbitrary classical data with two parameters: λ\lambda, the partition size of memory, and γ\gamma, the size of the CNOT subtree within a partition, with

n=log⁡2N,λ=2n−d,γ=2n−d−d′.n=\log_2 N,\qquad \lambda=2^{n-d},\qquad \gamma=2^{n-d-d'}.

The architecture has three stages: address setting via linear routers and a CSWAP tree, memory querying within partitions, and retrieval by a final CSWAP tree (Zhu et al., 2024).

The main theorem states that for NN memory locations,

T=O ⁣(Nγ+Nλlog⁡Nλ+λ),Q=O ⁣(log⁡Nλ+λ),T=O\!\left(\frac{N}{\gamma}+\frac{N}{\lambda}\log\frac{N}{\lambda}+\lambda\right), \qquad Q=O\!\left(\log\frac{N}{\lambda}+\lambda\right),

with an explicit infidelity expression that separates long-range gate error, SWAP error, idling error, CNOT error, CCNOT error, and CSWAP error. A highlighted regime is

λ=N,γ=N1/4,\lambda=\sqrt N,\qquad \gamma=N^{1/4},

which yields

O~(N3/4) infidelity,O(N3/4) T,O(N) Q.\tilde O(N^{3/4}) \text{ infidelity},\qquad O(N^{3/4}) \text{ }T,\qquad O(\sqrt N)\text{ }Q.

The paper identifies this as simultaneous sublinear scaling in infidelity, TT-count, and qubit count (Zhu et al., 2024).

For multi-bit readout with word size bb, the unified architecture offers parallel and sequential schemes. Parallel multi-bit readout makes bb copies of the single-bit structure, with resource costs that scale with bb. Sequential multi-bit readout reuses the routed signal and repeats Stage III bb times, giving better TT-efficiency but extra idling error, specifically O~(bI+b2εI)\tilde O(b\mathbf I+b^2\varepsilon_I). The paper positions these as tunable tradeoffs rather than universally superior alternatives (Zhu et al., 2024). This suggests that, in the quantum setting, “protocol” refers as much to routing architecture and fault-tolerant layout as to lookup semantics.

6. Logic synthesis, hardware mapping, and cross-cutting tradeoffs

In FPGA design, the phrase LUT refers to a physical or logical primitive rather than to a stored table queried at runtime. FuseMap nevertheless belongs to the same conceptual family because it is concerned with how a Boolean network is reshaped so that multi-input LUT covering becomes more effective. An FPGA LUT is described as a flexible digital memory structure that can implement any logic function of a limited number of inputs, typically 4 to 6 inputs. FuseMap uses an ASIC technology mapping step as a controllable pre-processing stage so that the resulting netlist is structurally more favorable for subsequent multi-input LUT packing (Yu, 15 Jul 2025).

The central claim is negative before it is positive: naively chaining ASIC mapping then LUT mapping is usually worse than vanilla LUT mapping, and motivating examples report LUT-count increases of about 7%7\% to 24%24\% in a vanilla ASIC+LUT flow. The useful regime arises only when a carefully chosen subset of standard cells is selected so that the mapped structure becomes more LUT-friendly. FuseMap therefore frames cell selection as a bandit problem over a standard-cell library L\mathcal{L}, supports #LUT\#LUT, delay, and area-delay product minimization, defines ADP=Delay×#LUTADP=Delay\times \#LUT, and uses ϵ\epsilon-greedy and UCB strategies to update cell-selection probabilities (Yu, 15 Jul 2025).

On a 24-design ASAP7 evaluation, the paper reports #LUT\#LUT improvement in 20 out of 24 designs, average #LUT\#LUT improvement of about 9%9\%, average delay improvement around 3%3\%, and average ADP improvement around 9%9\%. It also reports convergence usually within 10–12 iterations and notes that aggressive shrinking of the library can increase the probability of failed mapping (Yu, 15 Jul 2025). The underlying message is that multi-input LUT realization quality depends strongly on the intermediate structure exposed to the mapper.

Across the surveyed literature, several recurring tradeoffs appear. First, direct lookup is rarely the whole story: the decisive issue is how the address space is engineered. LUT-NN requires end-to-end centroid learning rather than vanilla PQ; Hawk uses either one-time masks or noisy EC-derived reusable keys; the unified quantum architecture requires parameterized routing and CSWAP-based error containment; and FuseMap relies on design-specific cell subset selection rather than generic library use (Tang et al., 2023, Saleem et al., 2024, Zhu et al., 2024, Yu, 15 Jul 2025). Second, multi-input generality often creates exponential pressure. Table size grows exponentially with input precision or arity in Tabula and TableNet, the unary-iterate quantum lookup is exponential in address width kk, and Hawk treats $\softmax$ through two univariate tables precisely to avoid a huge multivariate LUT (Lam et al., 2022, Wu, 2019, Häner et al., 2022, Saleem et al., 2024). Third, performance gains are usually contingent on hardware-conscious layout or execution: SIMD shuffle instructions in LUT-NN, cache-aware streamed lookup in Vec-LUT, lattice-surgery routing in surface-code lookup, and nearest-neighbor planar layout in the unified quantum architecture (Tang et al., 2023, Li et al., 6 Dec 2025, Häner et al., 2022, Zhu et al., 2024).

A plausible implication is that the enduring significance of multi-input lookup-table protocols lies less in any single implementation and more in a general design principle: when repeated computation can be reorganized into structured address formation plus retrieval, the dominant costs shift from arithmetic to representation, routing, security, or memory locality. The modern literature shows this principle operating in approximation-aware DNN inference, private nonlinear computation, fault-tolerant quantum data access, and FPGA logic packing, with each domain defining its own notion of what the “multiple inputs” are and what constraints make lookup preferable to direct computation.

Topic to Video (Beta)

No one has generated a video about this topic yet.

Whiteboard

No one has generated a whiteboard explanation for this topic yet.

Follow Topic

Get notified by email when new papers are published related to Multi-Input Lookup Table Protocol.