- The paper introduces AFSAT, a GPU-accelerated SAT solver that reformulates pseudo-Boolean constraints using Walsh-Fourier analysis for efficient GPU parallelism.
- It employs projected gradient descent and vectorized DFT to optimize heterogeneous constraint evaluations while mitigating floating-point instability.
- Experimental results demonstrate superior throughput and memory efficiency compared to prior continuous relaxation solvers like FastFourierSAT.
Accelerated Fourier SAT (AFSAT): GPU-based Symmetric Pseudo-Boolean SAT Solving
Problem Motivation and Theoretical Base
The paper introduces Accelerated Fourier SAT (AFSAT), a production-level GPU-accelerated SAT solver targeting pseudo-Boolean (PB) satisfiability problems by leveraging continuous local search (CLS) underpinned by multilinear Walsh-Fourier analysis. Traditional SAT solvers, especially for PB constraints, often rely on CNF encodings, which can lead to a significant blowup in size and loss of the native structure present in PB formulations. The motivation for AFSAT is to exploit the symmetry and algebraic properties of PB constraints, encoding SAT as a continuous, bounded, differentiable optimization problem. This formulation is tractable to massively parallel, gradient-based optimization on modern GPU architectures.
AFSAT follows the continuous relaxation pioneered in prior work such as FastFourierSAT [cen2025massively], but extends and fully engineers the implementation to address both representational scalability and numerical stability, overcoming concrete limitations regarding constraint heterogeneity, floating-point instability, and device memory utilization.
Algorithmic Framework and Implementation
AFSAT represents Boolean variables as real-valued variables mapped onto the hypercube via {−1,1} encoding, with SAT constraints reformulated as multilinear polynomials using Walsh-Fourier expansions. For symmetric PB constraints—where satisfaction is invariant under variable permutations—the construction and evaluation of these expansions are optimized via vectorized Discrete Fourier Transforms (DFT). The evaluation pipeline exploits the algebraic equivalence between elementary symmetric polynomials and DFT/permutation symmetries, enabling efficient batched computation.
The solver is implemented in Python, utilizing the JAX compiler for:
- Pure function composition,
- Automatic vectorization,
- Automatic differentiation,
- JIT compilation targeting GPU/XLA backends.
Crucially, the solver kernel is compiled once and executed against batches of random (or partially-assigned) initializations, allowing efficient exploration of the solution space within the bounded ℓ∞-norm cube. The core optimization method is projected gradient descent (PGD) with batch-level parallelism. The system also supports partial assignments, enabling use within decomposition frameworks (e.g., integration as a subsolver in portfolio approaches or solvers such as Dagster).
Constraint Typing, Heterogeneity, and Numerical Stability
AFSAT is distinguished by its support for arbitrary heterogeneous mixtures of symmetric PB constraint types—disjunction (OR), at-most-one (AMO), exactly-one (EO), exactly-k, not-all-equal (NAE), exclusive-or (XOR), and threshold cardinality—in the same problem instance. Closed-form algorithms for Fourier coefficient computation for each constraint class are implemented with complexity tailored to the constraint's combinatorial structure, leveraging idempotent variable symmetry.
A notable engineering contribution is the redesign of DFT-based evaluation to account for floating-point instability arising in high-constraint-length scenarios (n⪆50). Catastrophic cancellation and representational limits of IEEE 754 64-bit floating point are partially ameliorated via:
- Exact construction of DFT matrices retaining conjugate symmetry,
- Deferred floating-point division until the last computation stage,
- Mirror-based computation for algebraic redundancy,
- Empirical monitoring and limiting of constraint length.
AFSAT demonstrates a strict improvement in runtime performance, memory efficiency, and numerical stability over FastFourierSAT and analogous proof-of-concept solvers. The pipeline reduces GPU memory consumption by compacting auxiliary data, optimizing DFT matrix allocation, and minimizing pre-processing and kernel launch overhead. Experimental evaluations conducted on Volta-class GPU clusters demonstrate that AFSAT achieves worst-case parity and otherwise strictly better performance than FastFourierSAT, with observed lower baseline and peak solution times.
A central empirical result is the characterization of throughput dynamics on GPU architectures; peak throughput (number of independent gradient descents per unit time) is achieved when memory occupation remains within 0.1%−1% of available device RAM, tightly correlated with aggregate L1/L2 cache between all streaming processors. Throughput decays logarithmically beyond this point due to cache spill thrashing rather than main memory bandwidth, which establishes an operational regime for optimal batch size selection.
Additionally, AFSAT scales efficiently across multiple GPUs via JAX’s array sharding, providing near-linear throughput scaling in a single-program-multiple-data paradigm with negligible communication overhead due to the independence of batched gradient descents.
Solver Incompleteness, Integration, and Future Directions
AFSAT is an incomplete solver, in the sense that it cannot certify unsatisfiability due to the inherent nonconvex, saddle-dense nature of the continuous objective. However, it provides a natural MaxSAT/partial solution interface, returning best-effort assignments and unsatisfied constraint counts. This property, coupled with partial assignment support, positions AFSAT as a highly effective local search or subsolver in decomposition and hybrid SAT frameworks.
The paper highlights that constraint length and floating-point precision fundamentally limit the size and effective coverage of a single PB constraint. For long constraints, decomposition into shorter equivalents (except for certain classes such as exactly-k and general cardinality, where decompositions are more complex) is required to maintain numerical stability and throughput.
The discussion opens several directions for future work:
- Incorporation and engineering of bound-respecting second-order optimization methods (e.g., L-BFGS-B in JAX), to navigate the multiplicity of saddle points in the objective landscape, addressing stalling observed with first-order methods,
- Adaptive strategies for constraint weighting,
- Advanced integration within systematic and portfolio solvers,
- Exploration of hardware with extended or arbitrary-precision arithmetic to relieve constraint length ceilings,
- Potential application to other nonconvex combinatorial domains amenable to symmetric relaxation.
Conclusion
Accelerated Fourier SAT establishes a new baseline for CLS-based SAT solving, fully engineering Walsh-Fourier relaxation and DFT-based evaluation for the GPU-accelerated solution of symmetric PB SAT instances. The solver’s support for highly heterogeneous constraints, rigorous treatment of floating-point error, and scalable throughput on multi-GPU hardware extend the range of SAT problems for which continuous relaxation is a tractable and performant approach. While incomplete, AFSAT’s high-throughput, best-effort batch search is directly applicable as a component in advanced SAT architectures and as a subject for further theoretical analysis and hardware-aware optimization (2606.06641).