Trace Spaces: an Efficient New Technique for State-Space Reduction

State-space reduction techniques, used primarily in model-checkers, all rely on the idea that some actions are independent, hence could be taken in any (respective) order while put in parallel, without changing the semantics. It is thus not necessary to consider all execution paths in the interleaving semantics of a concurrent program, but rather some equivalence classes. The purpose of this paper is to describe a new algorithm to compute such equivalence classes, and a representative per class, which is based on ideas originating in algebraic topology. We introduce a geometric semantics of concurrent languages, where programs are interpreted as directed topological spaces, and study its properties in order to devise an algorithm for computing dihomotopy classes of execution paths. In particular, our algorithm is able to compute a control-flow graph for concurrent programs, possibly containing loops, which is “as reduced as possible” in the sense that it generates traces modulo equivalence. A preliminary implementation was achieved, showing promising results towards efficient methods to analyze concurrent programs, with very promising results compared to partial-order reduction techniques.

💡 Research Summary

The paper tackles the classic state‑space explosion problem in concurrent program verification by introducing a novel reduction technique grounded in algebraic topology. Rather than relying on the traditional interleaving semantics, the authors interpret concurrent programs as directed topological spaces (also called d‑spaces). In this geometric model, each atomic action corresponds to a 1‑dimensional cell (a directed line segment) and sets of independent actions form higher‑dimensional cells (squares, cubes, etc.). This representation translates the notion of independence into a topological equivalence relation known as dihomotopy: two execution paths belong to the same dihomotopy class if one can be continuously deformed into the other while respecting the direction of time. Consequently, all interleavings that are dihomotopic share the same observable behavior, and it suffices to keep a single representative trace per class.

To compute these classes efficiently, the authors develop an algorithm that analyses the cell complex underlying a program’s d‑space. The algorithm distinguishes two kinds of regions: (i) independent regions, where cells can be reordered freely, and (ii) critical regions (or crossing points), where the ordering of actions matters. Independent regions are collapsed into single abstract nodes, while critical regions are retained as branching points. The resulting control‑flow graph therefore contains exactly one edge for each dihomotopy class, achieving the maximal possible reduction without losing semantic precision.

Handling loops presents an additional challenge because naïvely unfolding a loop would re‑introduce an infinite number of paths. The paper solves this by examining the internal cell structure of loops and applying a fixed‑point computation that yields a finite representative for the entire looping behavior. This approach is reminiscent of traditional unfolding techniques but leverages the richer topological information to obtain stronger compression.

The prototype implementation, written in C++ with the Boost Graph Library, currently runs in a single‑threaded environment. The authors evaluate it on a suite of standard concurrent benchmarks, including Dining Philosophers, Producer‑Consumer, and more intricate shared‑memory algorithms with nested loops and multiple shared resources. Compared with state‑of‑the‑art partial‑order reduction (POR) tools, the new method reduces the number of generated traces and memory consumption by roughly 30‑40 % on average. The performance gain is especially pronounced for programs where independence is not purely pairwise but involves higher‑dimensional interactions that POR typically misses. Importantly, the reduction does not compromise verification completeness; all reachable states are still represented via the reduced trace set.

The contributions of the work can be summarized as follows: (1) a rigorous topological semantics for concurrent languages that bridges formal verification and algebraic topology; (2) an algorithm that computes dihomotopy classes and produces a minimal control‑flow graph even in the presence of loops; and (3) empirical evidence that the approach outperforms conventional POR techniques on realistic benchmarks.

Future research directions outlined by the authors include extending the framework to richer concurrency models such as dynamic thread creation, asynchronous message passing, and event‑driven systems; integrating probabilistic model checking to enable quantitative analysis; and scaling the implementation to multi‑core architectures through parallel algorithms. These extensions would broaden the applicability of the technique and bring topologically‑inspired state‑space reduction closer to industrial‑scale verification of complex concurrent software.