Traditional deep learning is built on the mathematical abstraction of the Multiply-Accumulate (MAC) operation. While elegant on paper, MAC operations are expensive to implement in silicon. To perform a single multiplication, general-purpose hardware must orchestrate a complex sequence of instruction fetches, memory accesses, and logic gate toggles. This "arithmetic tax" creates a bottleneck for applications requiring nanosecond-level responses, such as high-energy physics triggers or line-rate network security.
A growing body of research suggests a radical alternative: bypassing arithmetic entirely by mapping neural networks directly to the native Boolean logic of hardware.
Neurons as Truth Tables
The core intuition behind this shift is that a quantized neuron—one that takes a small number of discrete inputs and produces a discrete output—is fundamentally just a Boolean function. Instead of calculating $y = \sigma(\sum wx + b)$, we can treat the neuron as a Truth Table.
In Field-Programmable Gate Arrays (FPGAs), the fundamental building block is the Look-Up Table (LUT). A $K$-input LUT is a small piece of memory that can store the output for every possible combination of $K$ binary inputs. As Erwei Wang et al. argue in LUTNet: Learning FPGA Configurations for Highly Efficient Neural Network Inference, we can treat these LUTs as learnable operators. Rather than using LUTs to emulate a fixed gate like an XNOR, the network can learn the optimal Boolean function for each hardware unit, leveraging the full non-linear expressive power of the FPGA's native fabric.
By representing neurons this way, the distinction between memory and computation disappears. The "weights" are no longer numbers stored in RAM; they are the configuration bits of the logic gates themselves.
Combinational Inference
When a neural network is mapped directly to logic, it ceases to be a sequential program and becomes a combinational circuit. In a traditional processor, data moves through a pipeline controlled by a clock. In a combinational logic network, data simply "ripples" through the gates.
Manuele Rusci et al. demonstrate in Design Automation for Binarized Neural Networks: A Quantum Leap Opportunity? that this approach eliminates the energy overhead of instruction fetching and specialized controllers. This allows for "always-on" sensors that consume minimal power. Similarly, Yaman Umuroglu et al. show in LogicNets: Co-Designed Neural Networks and Circuits for Extreme-Throughput Applications that by enforcing extreme sparsity, entire layers can be physically instantiated as truth tables. This architecture achieves inference latencies in the sub-15 nanosecond range, enabling throughputs of hundreds of millions of inferences per second.
Learning the Logic
The challenge of this paradigm is training. Boolean functions are discrete and non-differentiable, making standard backpropagation difficult. Researchers have developed several strategies to bridge this gap:
- Differentiable Logic Gates: Christian Borgelt et al. propose Logic Gate Networks in Convolutional Differentiable Logic Gate Networks, which use continuous relaxations of logic gates (like NAND and XOR) to allow gradient-based learning.
- Extended Finite Differences: Alan Tendler Leibel Bacellar et al. introduce Differentiable Weightless Neural Networks (DWNs) in Differentiable Weightless Neural Networks, using numerical approximations to update LUT entries directly.
- Probabilistic Relaxation: Lino Gerlach et al. utilize Walsh-Hadamard transforms in WARP-LUTs to create a differentiable path for training probabilistic look-up tables.
Hardware-Software Co-Design
To make these models practical, the software must understand the physical constraints of the hardware. Modern FPGAs have specific LUT sizes (often 6-input). Marta Andronic et al. show in NeuraLUT-Assemble that by assembling "logical" neurons from trees of physical LUTs, one can build high-accuracy models that fit perfectly into the device's routing resources.
Even when LUTs are not the primary target, the logic-mapping philosophy holds. Soheil Nazar Shahsavani et al. demonstrate in Efficient Compilation and Mapping of Fixed Function Combinational Logic onto Digital Signal Processors that even Digital Signal Processor (DSP) blocks can be repurposed to execute fixed-function combinational logic, achieving significant speedups over traditional MAC-based execution.
By treating hardware not as a generic calculator but as a flexible fabric of Boolean operators, this research direction enables a new class of "faster than real-time" simulation and inference (Juan Ospina et al., Faster than Real-Time Simulation), pushing neural networks into domains where microseconds matter.
Key Foundational Work
LUTNet: Learning FPGA Configurations for Highly Efficient Neural Network Inference (2019) — contributed 2 concept elements to this direction.
Design Automation for Binarized Neural Networks: A Quantum Leap Opportunity? (2017) — contributed 2 concept elements to this direction.
LUTNet: Rethinking Inference in FPGA Soft Logic (2019) — contributed 2 concept elements to this direction.