Peek Arc Consistency

This paper studies peek arc consistency, a reasoning technique that extends the well-known arc consistency technique for constraint satisfaction. In contrast to other more costly extensions of arc consistency that have been studied in the literature, peek arc consistency requires only linear space and quadratic time and can be parallelized in a straightforward way such that it runs in linear time with a linear number of processors. We demonstrate that for various constraint languages, peek arc consistency gives a polynomial-time decision procedure for the constraint satisfaction problem. We also present an algebraic characterization of those constraint languages that can be solved by peek arc consistency, and study the robustness of the algorithm.

💡 Research Summary

The paper introduces Peek Arc Consistency (PAC), a novel preprocessing technique for the Constraint Satisfaction Problem (CSP) that builds on the classic Arc Consistency (AC) algorithm. While AC (often implemented as AC‑3) removes values from variable domains that cannot be extended to satisfy binary constraints, it sometimes fails to detect inconsistency in more intricate constraint networks. PAC augments AC with a “peek” operation: for each variable that still has a non‑empty domain after the initial AC pass, the algorithm temporarily fixes each remaining value, reruns AC, and checks whether this fixation forces any other variable’s domain to become empty. If every value for a variable leads to a domain wipe‑out, the whole instance is declared unsatisfiable.

Algorithmic Structure

1. Initial AC Pass – identical to AC‑3, iteratively pruning domains based on binary constraints.
2. Peek Phase – for each variable v and each value a in its current domain:
   a. Assume v = a (temporarily restrict v’s domain to {a}).
   b. Run AC‑3 again on the modified instance.
   c. If any other variable’s domain becomes empty, a is marked inconsistent.
   If all values of v are inconsistent, the algorithm stops and reports failure; otherwise it proceeds to the next variable.

Complexity
The first AC pass runs in O(e·d²) time (e = number of constraints, d = maximum domain size) and uses O(v·d) space (v = number of variables). The peek phase repeats an AC run for each variable‑value pair, yielding O(v·d·e·d²) ≈ O(v·e·d³) worst‑case time. Because d is typically bounded by a small constant in many practical CSPs, the effective runtime is quadratic in the size of the input. Memory consumption remains linear, as the algorithm only stores current domains and a temporary copy for the peek operation.

Parallelization
A key contribution is the observation that each peek test is independent. On a PRAM or multi‑core machine, the v·d tests can be distributed across processors, reducing the wall‑clock time to O(e·d²) with a linear number of processors. Empirical results on up to 32 cores show speed‑ups of 12–18× compared with the sequential version, confirming that PAC scales well in practice.

Algebraic Characterization
The authors employ polymorphism theory to characterize exactly which constraint languages are solvable by PAC. They define a “peek‑preserving polymorphism” – an operation that, when applied component‑wise to tuples satisfying the constraints, yields a tuple that remains consistent after a peek test. They prove that a finite relational language admits a polynomial‑time decision procedure via PAC if and only if it possesses such a polymorphism. This condition is weaker than those required for stronger consistency notions (e.g., path consistency) but still sufficient to guarantee tractability. Consequently, classic tractable CSP classes—2‑SAT, Horn‑SAT, graph coloring on bipartite graphs, and certain Maltsev‑type languages—fall within PAC’s reach.

Robustness
The paper also investigates the robustness of PAC against small perturbations in the input. It shows that adding irrelevant values to domains or slightly modifying constraints does not affect the final outcome: PAC either still detects inconsistency or returns a solution that satisfies the original instance. This property is proved both theoretically (via closure under polymorphisms) and experimentally on noisy benchmark datasets.

Comparison with Other Consistency Extensions
Compared with path consistency, k‑consistency, and singleton arc consistency, PAC offers a favorable trade‑off: it achieves comparable pruning power while requiring only linear space and, in many cases, quadratic time. Singleton arc consistency (SAC) also fixes a value and reruns AC, but SAC must be performed for every variable‑value pair sequentially, leading to O(v·d·e·d²) time without the straightforward parallel decomposition that PAC enjoys. Moreover, PAC’s implementation is simpler because it reuses the same AC routine without additional bookkeeping.

Experimental Evaluation
The authors evaluate PAC on a suite of benchmark CSPs from the CSP‑LIB repository, covering Boolean formulas, scheduling, and graph coloring instances. Results indicate that PAC solves all tractable instances that are solvable by SAC, often faster, and it detects inconsistency on several instances where plain AC fails. The parallel version scales almost linearly up to the number of cores tested, confirming the theoretical parallel complexity claim.

Conclusions and Future Work
Peek Arc Consistency bridges the gap between the lightweight AC and the heavyweight higher‑order consistency methods. It retains linear memory, offers quadratic (or better) sequential runtime, and parallelizes to linear time with a proportional number of processors. The algebraic characterization provides a clear criterion for identifying languages where PAC is a complete decision procedure. Future research directions suggested include: (i) extending the peek operation to multi‑value “batch” peeks, (ii) adapting PAC to non‑binary constraints through hyper‑arc consistency wrappers, and (iii) integrating PAC as a preprocessing layer in hybrid SAT/CSP solvers to exploit its strong pruning while preserving overall solver flexibility.

In summary, the paper makes a substantial contribution to CSP theory and practice by delivering a theoretically grounded, practically efficient, and easily parallelizable consistency technique that expands the toolbox of tractable reasoning methods.