🤖 machine learning

Differentiable Logic Synthesis: Spectral Coefficient Selection via Sinkhorn-Constrained Composition

This paper introduces a differentiable architecture for logic synthesis that uses Sinkhorn-constrained spectral composition and column-sign modulation to learn Boolean functions, demonstrating that while gradient descent struggles with high-dimensional complexity, a combination of ternary quantization and MCMC refinement can achieve 100% accuracy for hardware-efficient neuro-symbolic logic.

Original authors: Gorgi Pavlov

Published 2026-02-11

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Gorgi Pavlov

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot how to follow a set of strict, logical rules—like a recipe or a computer program.

Usually, when we teach robots using "Neural Networks" (the tech behind ChatGPT), we are teaching them by intuition. It’s like teaching a chef to cook by saying, "Add a little bit of salt until it tastes right." The chef gets very close, but they are always "guessing" with fuzzy amounts. If you try to turn that chef into a factory machine that must use exactly 5.00 grams of salt every single time, the chef might struggle because they don't actually understand the math; they just have a "feeling."

This paper, "Differentiable Logic Synthesis," proposes a way to teach robots logic using math instead of feelings.

Here is the breakdown of how they did it, using three simple metaphors.

1. The "Lego Brick" Approach (The Fourier Basis)

Instead of giving the robot a blank canvas and telling it to "draw a logic gate," the researchers gave it a box of pre-made Lego bricks.

In math, these bricks are called Fourier Coefficients. Every complex logical rule (like "If A and B are true, then do C") can be broken down into a specific combination of these "math bricks."

By using these bricks, the robot isn't "guessing" anymore. It is simply looking at its box and saying, "To make an 'AND' gate, I need exactly one Blue Brick, one Red Brick, and zero Green Bricks." Because the bricks are solid and discrete, the result is perfect every time. There is no "fuzziness."

2. The "Smart Traffic Controller" (Sinkhorn Routing)

Once the robot has its Lego bricks, it needs to connect them to build something big, like a calculator. This is where it gets tricky. If you connect too many bricks haphazardly, the signal gets lost, or the whole structure collapses under its own weight.

The researchers used a mathematical tool called Sinkhorn Routing. Think of this as a highly disciplined Traffic Controller at a massive intersection.

In a normal neural network, the traffic is chaotic; cars (signals) fly everywhere, causing crashes (errors).
The Sinkhorn Controller ensures that every car goes to exactly one destination, and no intersection gets overwhelmed. It keeps the "flow" of logic perfectly stable as you build bigger and bigger machines.

3. The "Translator" (Column-Sign Modulation)

There was one problem: the "Traffic Controller" was so focused on keeping things stable that it forgot how to do one basic thing—negation (the "NOT" rule). In logic, "NOT" is like a light switch that flips "On" to "Off." The original controller was only good at "combining" things, not "flipping" them.

The researchers added a tiny, brilliant fix called Column-Sign Modulation. Imagine if every car in our traffic metaphor also had a "Flip Switch." The controller directs the car to the right destination, and then the switch flips the signal from "Yes" to "No." This one small addition allowed the robot to master every single possible logical rule.

Why does this matter? (The "So What?")

Most AI is a "Black Box"—even the creators don't quite know why it makes certain decisions. It’s a mystery.

This paper creates a "Glass Box." Because the robot is using specific "Lego bricks" (Fourier coefficients) and a "Traffic Controller" (Sinkhorn), you can look inside and see exactly why it made a decision. You can see the exact "bricks" it used.

The result?

Perfect Accuracy: It doesn't "approximate" logic; it is logic.
Super Speed: Because the math is so clean (using only -1, 0, and +1), it can run on tiny, cheap computer chips at lightning speed—nearly 11 billion operations per second!
Explainability: If the robot makes a mistake, you don't have to guess why. You can look at its "Lego instructions" and see exactly which brick was out of place.

In short: They found a way to teach AI to think with the precision of a mathematician, rather than the intuition of a human.

Technical Summary: Differentiable Logic Synthesis via Hierarchical Spectral Composition

Authors: Gorgi Pavlov, Ph.D. (Lehigh University & Johnson and Johnson)
Date: February 11, 2026

1. The Problem: The "Fuzzy" Gap in Neuro-Symbolic AI

A fundamental tension exists between gradient-based learning (neural networks) and discrete symbolic reasoning (Boolean logic). While neural networks excel at continuous pattern recognition, they struggle with exact logic for three reasons:

Quantization Degradation: Neural networks learn "soft" decision boundaries that fail when discretized for hardware deployment.
Lack of Interpretability: Learned weights in standard architectures lack semantic meaning, making them "black boxes."
Expressivity vs. Stability: Existing neuro-symbolic models (like NALUs or Logic Tensor Networks) often rely on continuous relaxations that are difficult to optimize or generalize beyond training distributions.

2. Methodology: Hierarchical Spectral Composition

The paper proposes a "transparent-by-design" architecture that shifts the learning target from arbitrary weights to spectral coefficients within a Boolean Fourier basis.

A. Boolean Fourier Basis & Ternary PTFs
Instead of learning gates from scratch, the model uses the Walsh-Hadamard basis. Any Boolean function can be represented as a sum of parity characters ( $\chi_S$ ). The architecture learns a Ternary Polynomial Threshold Function (PTF):
$\hat{y}(x) = \text{sign}\left(\sum_{S \subseteq [n]} w_S \chi_S(x)\right), \text{ where } w_S \in \{-1, 0, +1\}$
This ensures that learned representations are intrinsically interpretable: each coefficient $w_S$ represents the correlation of the function with a specific parity.

B. Sinkhorn-Constrained Routing with Column-Sign Modulation
To compose these primitives into complex logic (e.g., building an adder from XOR/AND gates), the paper adapts Manifold-Constrained Hyper-Connections (mHC).

Sinkhorn Projection: Routing matrices are projected onto the Birkhoff polytope (doubly stochastic matrices) using Sinkhorn-Knopp iterations. This ensures signal stability and prevents vanishing/exploding gradients during composition.
Column-Sign Modulation: Since pure doubly stochastic matrices can only produce convex combinations (preventing negation), the authors introduce a learned sign vector $s \in \{-1, +1\}^n$ . This allows the model to express Boolean negations (NAND, NOR) while maintaining the stability of the Sinkhorn framework.

C. Optimization Scaffolding
To overcome the non-differentiability of ternary weights, the authors use Gumbel-Softmax ternary relaxation and a Ternary Attractor Regularizer to bias the optimization toward the discrete set $\{-1, 0, +1\}$ .

3. Key Contributions

Architectural Extension: Successfully adapted mHC (originally for LLM stability) to logic synthesis by adding sign modulation to enable negation.
Mathematical Proofs: Provided theoretical evidence for the "zero-loss quantization" property, proving that if the model achieves 100% accuracy in a soft state, it will maintain it when quantized to hard ternary masks.
Universal Representability Verification: Through exhaustive enumeration, the paper proves that for $n \le 4$ , every possible Boolean function can be represented by a ternary PTF.
Operator-Theoretic Interpretability: Introduced spectral diagnostics (Spectral Gap $\Delta$ and Spectral Entropy $H_\sigma$ ) to measure routing commitment and stability, providing a formal way to interpret "how" a model routes information.

4. Results and Validation

The paper validates the approach across five distinct phases:

Phases 1–4 (Small Scale): Achieved 100% accuracy on all canonical Boolean operations for $n=2, 3, \text{ and } 4$ . The models converged to exact ternary masks, enabling zero-loss quantization.
Phase 5 (Scalability & Oracle Learning):
- Exact Transforms: Scaled the Fast Walsh-Hadamard Transform (FWHT) to $n=28$ , reaching 1.64 billion coefficients/sec.
- Symbolic Integration: Demonstrated that injecting domain knowledge (e.g., symmetry constraints for the Majority function) boosts accuracy from 72% to 86% ( $p < 0.001$ ), proving that symbolic priors outperform black-box learning.
Hardware Efficiency: Demonstrated a throughput of 10,959 MOps/s on a GPU. Because the learned weights are ternary, the models compile directly to combinational logic, bypassing the need for floating-point arithmetic.
Circuit Composition: Successfully built and verified 64-bit Ripple Adders and 128-bit Equality Comparators using hierarchical composition of learned 3-variable primitives.

5. Significance

This work establishes a new paradigm for Explainable Neuro-Symbolic AI. By grounding the architecture in Fourier analysis, the authors move away from post-hoc explanations toward inherent transparency. The ability to learn exact, discrete logic via continuous gradient descent—and then deploy that logic with the efficiency of hand-coded RTL—bridges the gap between high-level AI reasoning and low-level hardware implementation.