AFSAT: GPU-Accelerated Fourier SAT Solver

• Accelerated Fourier SAT (AFSAT) is a GPU-accelerated solver that extends prior FourierSAT work by supporting heterogeneous symmetric pseudo-Boolean constraints via a continuous local search kernel.
• It leverages a tailored discrete Fourier transform to compute elementary symmetric polynomials, enhancing numerical stability and throughput through vectorized GPU execution.
• The solver employs projected gradient descent with JAX-based automatic differentiation and array sharding to achieve near-linear scalability while addressing memory and precision challenges.

Searching arXiv for AFSAT and related FourierSAT/FastFourierSAT papers. Accelerated Fourier SAT (AFSAT) is a fully engineered, GPU-accelerated solver for pseudo-Boolean satisfiability problems whose constraints are symmetric. It realizes and extends the FourierSAT/FastFourierSAT line of work by supporting heterogeneous mixtures of symmetric pseudo-Boolean constraints within the same instance, providing a robust continuous local search (CLS) kernel compiled via JAX/XLA with automatic differentiation and vectorization, addressing numerical stability issues through a tailored discrete Fourier transform (DFT) construction, and scaling nearly linearly across multiple accelerators using array sharding (Christopher et al., 4 Jun 2026). In its immediate lineage, FourierSAT introduced a Fourier expansion-based algebraic framework for solving hybrid Boolean constraints (Kyrillidis et al., 2019), and FastFourierSAT supplied a proof-of-concept GPU-oriented realization based on gradient-driven CLS and an FFT-inspired convolution pipeline for elementary symmetric polynomials (ESPs) (Cen et al., 2023). The supplied literature also uses the acronym AFSAT for a distinct quantum-inspired projection-and-decimation solver instantiated by AmplificationSAT (Lanham, 2022).

1. Historical lineage and conceptual positioning

FourierSAT is an incomplete SAT solver based on Fourier analysis of Boolean functions. Its core construction is the sum of closed-form Fourier expansions of clauses, relaxed from $\{-1,1\}^n$ to $[-1,1]^n$, yielding a differentiable objective suitable for gradient-based search; the framework was designed for systems consisting of different types of constraints, including CNF, XOR, NAE, and cardinality constraints (Kyrillidis et al., 2019).

FastFourierSAT is a highly parallel hybrid SAT solver based on gradient-driven continuous local search. In that work, Accelerated Fourier SAT refers to a CLS framework that accelerates the evaluation and differentiation of Walsh expansions for Boolean constraints by exploiting FFT-inspired convolution and massive GPU parallelism. The concrete realization, FastFourierSAT, computes the dominant quantities—ESPs and their gradients—via an FFT-inspired batched convolution that is vectorized and amenable to GPU execution, achieves the same asymptotic work complexity as the best sequential CLS, and incorporates restart heuristics native to CLS (Cen et al., 2023).

The 2026 AFSAT system is the fully engineered successor in this line. It supports any heterogeneous mixture of symmetric constraint types and lengths within a single problem instance, uses JAX for pure function composition, automatic vectorisation, automatic differentiation, and just-in-time compilation, and emphasizes runtime performance, memory efficiency, and numerical stability (Christopher et al., 4 Jun 2026).

A recurring point of comparison is CDCL. In the FastFourierSAT formulation, CDCL solvers perform discrete, sequential search with conflict analysis and clause learning; they excel on CNF instances but are hard to exploit for fine-grained data-parallel acceleration. By contrast, FourierSAT, FastFourierSAT, and AFSAT move the computational bottleneck to evaluating and differentiating polynomials, described as structured linear algebra that maps naturally to GPUs (Cen et al., 2023).

2. Problem class, representations, and optimization objective

AFSAT focuses on symmetric pseudo-Boolean constraints. Formally, let $S \subseteq \{1,\dots,n\}$ index a subset of variables $x \in \{0,1\}^n$. A constraint $C$ over $S$ is symmetric if there exists a function $h : \{0,\dots,|S|\} \to \{0,1\}$ such that

$C(x) = h\!\left(\sum_{i \in S} x_i\right).$

Under the Walsh-Fourier embedding, variables are mapped to $X \in \{-1,1\}^n$, and symmetricity equivalently means that $C$ depends only on the Hamming weight, or equivalently the sum of literals, of the subset (Christopher et al., 4 Jun 2026).

AFSAT accepts hybrid instances via an extended DIMACS-like input grammar and internally normalizes CARD inequalities to $[-1,1]^n$0 or $[-1,1]^n$1 forms. Its parser performs automatic simplifications, including unit propagation, trivial elimination of constraints like CARD-0, EO units, reductions such as CARD-1$[-1,1]^n$2CNF and EK-1$[-1,1]^n$3EO, and detection of conflicting units (Christopher et al., 4 Jun 2026).

Constraint type	Form
CNF disjunction (OR)	$[-1,1]^n$4
At-most-one (AMO)	$[-1,1]^n$5
Exactly-one (EO)	$[-1,1]^n$6
Exactly-k (EK)	$[-1,1]^n$7
Not-all-equal (NAE)	$[-1,1]^n$8
XOR (odd parity)	$[-1,1]^n$9
Cardinality-k threshold (CARD)	$S \subseteq \{1,\dots,n\}$0, plus $S \subseteq \{1,\dots,n\}$1 variants

The continuous formulation is a Walsh-Fourier relaxation. For a Boolean formula $S \subseteq \{1,\dots,n\}$2 decomposed into symmetric constraints $S \subseteq \{1,\dots,n\}$3 over $S \subseteq \{1,\dots,n\}$4, the Fourier expansion is

$S \subseteq \{1,\dots,n\}$5

and AFSAT minimizes

$S \subseteq \{1,\dots,n\}$6

Satisfaction corresponds to $S \subseteq \{1,\dots,n\}$7, since each satisfied constraint contributes $S \subseteq \{1,\dots,n\}$8; violation increases the energy above $S \subseteq \{1,\dots,n\}$9 per constraint. The solver also computes

$x \in \{0,1\}^n$0

No extra penalty terms or smoothing are required because the Walsh-Fourier expansion is multi-linear and differentiable on $x \in \{0,1\}^n$1; projection enforces bounds, and optional partial assignments are handled via gradient masking (Christopher et al., 4 Jun 2026).

In the FastFourierSAT precursor, the same basic idea appears in weighted form. If $x \in \{0,1\}^n$2 has constraints $x \in \{0,1\}^n$3 and each constraint $x \in \{0,1\}^n$4 has Walsh expansion $x \in \{0,1\}^n$5, then

$x \in \{0,1\}^n$6

There, $x \in \{0,1\}^n$7 is satisfiable iff

$x \in \{0,1\}^n$8

and if a minimizer $x \in \{0,1\}^n$9 lies on $C$0, $C$1 encodes a satisfying assignment (Cen et al., 2023).

3. Walsh expansions, elementary symmetric polynomials, and DFT evaluation

For symmetric constraints, AFSAT exploits the fact that the Walsh-Fourier evaluation can be written in terms of elementary symmetric polynomials. For a symmetric constraint over $C$2 literals with continuous values $C$3,

$C$4

where $C$5 are the Fourier coefficients grouped by cardinality $C$6 and $C$7 are ESPs, the sum over all $C$8-sized products of distinct variables (Christopher et al., 4 Jun 2026).

The generating-polynomial viewpoint is central in the FastFourierSAT derivation:

$C$9

This identifies the ESP vector with the coefficients of a product polynomial and makes convolution the natural computational primitive (Cen et al., 2023).

AFSAT computes ESPs in the frequency domain using a tailored DFT. Let $S$0 be the $S$1-dimensional DFT matrix with entries

$S$2

and let $S$3 be the conjugate transpose. For each variable $S$4, form the padded sequence $S$5. Then

$S$6

which yields the compact product form

$S$7

Constraint evaluation then becomes

$S$8

This DFT-based construction is the basis of both the FastFourierSAT proof-of-concept and the engineered AFSAT solver (Christopher et al., 4 Jun 2026).

FastFourierSAT states the complexity in clause-local terms. For a clause of length $S$9, outer addition costs $h : \{0,\dots,|S|\} \to \{0,1\}$0 additions, row-wise reduce-product costs $h : \{0,\dots,|S|\} \to \{0,1\}$1 multiplications, and the final contraction costs $h : \{0,\dots,|S|\} \to \{0,1\}$2 flops, for total sequential work $h : \{0,\dots,|S|\} \to \{0,1\}$3, matching GradSAT’s $h : \{0,\dots,|S|\} \to \{0,1\}$4 and improving on FourierSAT’s $h : \{0,\dots,|S|\} \to \{0,1\}$5 explicit gradient. Under unlimited resources, the balanced tree structure gives ideal parallel time $h : \{0,\dots,|S|\} \to \{0,1\}$6 (Cen et al., 2023).

The same structure also explains a special case of practical importance. For XOR constraints, the Walsh spectrum is degenerate, and algebraic simplifications eliminate the transforms entirely, reducing work to $h : \{0,\dots,|S|\} \to \{0,1\}$7 and avoiding complex arithmetic (Cen et al., 2023).

4. Gradients, projected descent, and execution model

AFSAT uses Projected Gradient Descent with line search and projection to $h : \{0,\dots,|S|\} \to \{0,1\}$8 after each step. A single PGD iteration computes a step length $h : \{0,\dots,|S|\} \to \{0,1\}$9 via a lineSearch procedure and updates

$C(x) = h\!\left(\sum_{i \in S} x_i\right).$0

Stopping occurs when either the step size falls below a threshold, $C(x) = h\!\left(\sum_{i \in S} x_i\right).$1, a satisfying assignment is found with $C(x) = h\!\left(\sum_{i \in S} x_i\right).$2, or a max-iteration limit $C(x) = h\!\left(\sum_{i \in S} x_i\right).$3 is reached. AFSAT runs PGD in parallel across a batch $C(x) = h\!\left(\sum_{i \in S} x_i\right).$4 of candidate assignments; converged candidates idle until the batch finishes (Christopher et al., 4 Jun 2026).

The gradient can be obtained analytically in a form conforming to the DFT evaluation. For a literal index $C(x) = h\!\left(\sum_{i \in S} x_i\right).$5 in a clause,

$C(x) = h\!\left(\sum_{i \in S} x_i\right).$6

hence

$C(x) = h\!\left(\sum_{i \in S} x_i\right).$7

AFSAT nevertheless uses JAX automatic differentiation end-to-end, while retaining the analytic form as a structural explanation of the computation (Christopher et al., 4 Jun 2026).

FastFourierSAT made the same derivative structure explicit through the ESP identity

$C(x) = h\!\left(\sum_{i \in S} x_i\right).$8

so that for a symmetric clause

$C(x) = h\!\left(\sum_{i \in S} x_i\right).$9

That paper also described restart heuristics native to CLS. Weighting uses an ERWA update,

$X \in \{-1,1\}^n$0

with $X \in \{-1,1\}^n$1 and $X \in \{-1,1\}^n$2 derived from normalized unsatisfaction counts across parallel tasks; rephasing alternates among Original, Flipped, and Random phases, with $X \in \{-1,1\}^n$3 for SAT-like tasks and $X \in \{-1,1\}^n$4 for optimization tasks (Cen et al., 2023).

In systems terms, the two implementations occupy different points in the design space. FastFourierSAT describes custom kernels, shared-memory staging of $X \in \{-1,1\}^n$5, warp-level reductions, and clause bucketing by length. AFSAT instead emphasizes pure function composition, JIT compilation with XLA, automatic vectorization over batch candidates, automatic differentiation, and array sharding across multiple GPUs in a compute-follows-data SPMD regime (Cen et al., 2023, Christopher et al., 4 Jun 2026).

5. Numerical stability, memory behavior, and throughput engineering

AFSAT’s 2026 contribution is not only algorithmic generalization but also numerical engineering. The product terms

$X \in \{-1,1\}^n$6

can reach magnitude approximately $X \in \{-1,1\}^n$7 when $X \in \{-1,1\}^n$8 and $X \in \{-1,1\}^n$9, or vanish like $C$0 when $C$1. The supplied description states that this stresses IEEE-754 FP64 when $C$2, yields catastrophic cancellation in the inverse DFT and incorrect energies, and can produce exploding or vanishing gradients (Christopher et al., 4 Jun 2026).

AFSAT addresses these issues through a tailored DFT for conjugate symmetry and precision. The forward and inverse DFT matrices are constructed explicitly to guarantee exact conjugate symmetry between paired terms; cumulative error from repeated exponentiation that violates conjugate pairing is avoided; combinatorial Fourier-coefficient terms are computed in arbitrary-precision integer arithmetic with divisions and float conversion deferred to the last stage; and algebraic symmetry is mirrored explicitly rather than computing both halves independently. The implementation uses FP64, and the crucial improvements are attributed to the symmetry-preserving DFT matrix construction, avoiding repeated exponentiation error, and deferred floating-point operations (Christopher et al., 4 Jun 2026).

Memory efficiency and throughput are treated as first-order design constraints. AFSAT stores only essential arrays: precomputed small DFT matrices per clause length, literal index lists, and Fourier coefficient vectors. Peak throughput occurs at batch sizes that consume approximately $C$3 of GPU memory, correlated to roughly twice the device’s cache size. Larger batches saturate memory, causing cache thrashing and latency that reduce completed descents per unit time; beyond the peak, throughput decays roughly logarithmically with memory consumption (Christopher et al., 4 Jun 2026).

The proof-of-concept FastFourierSAT presents the same issue in a lower-level form. It recommends contiguous clause literals in global memory, contiguous storage of precomputed transformed coefficients, structure-of-arrays for coalesced reads across clauses, shared-memory storage for per-clause $C$4, and uniform clause lengths within a batch or padding to the next power-of-two to reduce divergence (Cen et al., 2023).

Taken together, these engineering choices indicate that AFSAT’s practical contribution is not reducible to a single transform identity. The supplied evidence points instead to a solver architecture in which numerical conditioning, cache behavior, vectorization strategy, and batching policy are tightly coupled (Christopher et al., 4 Jun 2026).

6. Empirical results, limitations, and adjacent usages of the acronym

FastFourierSAT reports that gradient computation is accelerated by over $C$5 versus CPU CLS prototypes on large instances. Specific RQ1 numbers are approximately $C$6 for xor3, approximately $C$7 for card3, and approximately $C$8 on small instances where preprocessing dominates. On the benchmark suites summarized in the supplied text, FastFourierSAT solved all cardinality instances, solved all parity-learning instances via diversified multi-start and GPU acceleration, achieved average scores near $C$9 on MSE’19 MaxCut, and on large planted partition graphs achieved best solutions for $[-1,1]^n$00 instances versus $[-1,1]^n$01 for the virtual best solver without CLS (Cen et al., 2023).

AFSAT replicates FastFourierSAT’s random cardinality and XOR-based parity learning benchmarks and also runs mixed heterogeneous pseudo-Boolean instances. It achieves equal or better cumulative solution times than FastFourierSAT, worst-case parity with universally lower baseline times due to improved preprocessing and kernel compilation or optimization, substantially reduced GPU memory use via compact data structures and tailored DFT matrices, and near-linear throughput scaling with GPU count through JAX array sharding. The experiments were run on NCI’s Gadi supercomputer, using the Volta partition with NVIDIA Tesla V100 GPUs (Christopher et al., 4 Jun 2026).

The method remains incomplete. The supplied description states that CLS cannot certify unsatisfiability; AFSAT therefore functions naturally as a MaxSAT solver, reporting unsatisfied-constraint counts and best-found assignments. It also identifies a practical ceiling around $[-1,1]^n$02, with constraints of length $[-1,1]^n$03 often exhibiting degeneracy on FP64 GPUs. Long constraints should be decomposed into shorter equivalents where possible; the multi-linear objective hosts many saddle points; first-order PGD can stall; success probability and throughput are materially affected by step-size schedules and batch sizes; and very long clauses in a heterogeneous mix can dominate memory layout and suppress throughput (Christopher et al., 4 Jun 2026).

Several misconceptions are explicitly addressed by the supplied literature. In the FastFourierSAT paper, “hybrid” refers to combining continuous optimization with history-aware heuristics and a multi-start portfolio on GPUs, not to coupling with CDCL, and hybridization with CDCL is discussed only as a future direction. The same source notes that on CNF-heavy, propagation-driven industrial instances, CDCL or portfolio approaches may still outperform CLS (Cen et al., 2023).

A separate ambiguity concerns the acronym itself. The supplied description attached to “Quantum-Inspired Approximations to Constraint Satisfaction Problems” uses AFSAT for a projection-and-decimation SAT solver instantiated by AmplificationSAT. That method constructs low-complexity approximations $[-1,1]^n$04 to the oracle $[-1,1]^n$05 via orthogonal projection,

$[-1,1]^n$06

refines the approximation by enlarging the column space, and retrieves assignments through bias-guided decimation using $[-1,1]^n$07. This is a distinct algorithmic line from the GPU DFT-based CLS solver that now predominates under the name Accelerated Fourier SAT (Lanham, 2022).