A Note on the Complexity of Model-Checking Bounded Multi-Pushdown Systems

In this note, we provide complexity characterizations of model checking multi-pushdown systems. Multi-pushdown systems model recursive concurrent programs in which any sequential process has a finite control. We consider three standard notions for boundedness: context boundedness, phase boundedness and stack ordering. The logical formalism is a linear-time temporal logic extending well-known logic CaRet but dedicated to multi-pushdown systems in which abstract operators (related to calls and returns) such as those for next-time and until are parameterized by stacks. We show that the problem is EXPTIME-complete for context-bounded runs and unary encoding of the number of context switches; we also prove that the problem is 2EXPTIME-complete for phase-bounded runs and unary encoding of the number of phase switches. In both cases, the value k is given as an input (whence it is not a constant of the model-checking problem), which makes a substantial difference in the complexity. In certain cases, our results improve previous complexity results.

💡 Research Summary

The paper investigates the model‑checking problem for multi‑pushdown systems (MPDS), which are a natural formalism for recursive concurrent programs where each thread has a finite‑state controller and its own stack. The authors focus on three well‑studied boundedness restrictions—context‑boundedness, phase‑boundedness, and stack‑ordering—and they study the complexity of checking specifications expressed in a linear‑time temporal logic that extends the well‑known CaRet logic to the multi‑stack setting. In this extended logic, the “next” and “until” operators are parameterised by a stack identifier, allowing one to refer explicitly to calls and returns on a particular stack.

Technical contributions

1. Context‑bounded model checking – A run is k‑context‑bounded if it contains at most k switches between the active stacks. The bound k is given as part of the input, encoded in unary (as a string of 1’s). The authors prove that the model‑checking problem under this restriction is EXPTIME‑complete. The upper bound is obtained by constructing a finite‑state automaton that simulates the MPDS while counting context switches with a counter of size O(k). The resulting product automaton has size exponential in k, but can be explored in exponential time. EXPTIME‑hardness follows by a reduction from the EXPTIME‑complete LTL model‑checking problem, after encoding a single‑stack system as a multi‑stack one.

2. Phase‑bounded model checking – A phase consists of a maximal sequence of push/pop operations on a single stack; a run is k‑phase‑bounded if it contains at most k phase changes. Again k is part of the input (unary). The paper shows that this problem is 2EXPTIME‑complete. The authors build a multi‑counter automaton that records the current phase and the contents of all stacks. The number of distinct phase configurations grows doubly exponentially in k, leading to a 2EXPTIME upper bound. 2EXPTIME‑hardness is established by a reduction from a known 2EXPTIME‑hard game on multi‑stack pushdown systems.

3. Stack‑ordering restriction – Here a linear order on the stacks is imposed, forbidding a lower‑indexed stack from being used while a higher‑indexed one still contains symbols. The authors observe that this restriction does not lower the lower bound: the problem remains EXPTIME‑hard, and they discuss how combining stack‑ordering with the other two restrictions can increase the overall complexity.

A notable aspect of the work is that the bound k is not a fixed constant but an input parameter. This distinction dramatically changes the complexity landscape: when k is a constant, the problems are known to be in PTIME or PSPACE, but with k as part of the input the authors obtain the tight exponential and double‑exponential bounds described above. The paper also points out several cases where their results improve on earlier work, for instance by providing exact upper bounds that match previously known lower bounds.

Methodology

The authors start by formalising MPDS and the extended CaRet‑like logic. They then define the three boundedness notions precisely and show how each can be encoded into a finite‑state or counter‑based representation. For the upper bounds they construct product automata that combine the system’s transition relation with the automaton for the specification, together with counters that track context or phase switches. The size of these products yields the exponential or double‑exponential time algorithms. For the lower bounds they use classic reductions: LTL model checking for EXPTIME‑hardness and a reduction from the 2EXPTIME‑hard emptiness problem for alternating pushdown systems for the phase‑bounded case.

Implications

The results give a clear picture of how the choice of boundedness and the treatment of the bound k affect the feasibility of automated verification for recursive concurrent programs. In practice, developers can use the EXPTIME algorithm for modest context bounds, while the 2EXPTIME algorithm for phase bounds is only realistic for very small k. Moreover, the paper’s techniques (counter‑augmented product constructions, stack‑parameterised temporal operators) can be reused in future extensions, such as richer logics or additional resource constraints.

In summary, the paper delivers tight complexity classifications for model checking of bounded multi‑pushdown systems, establishes EXPTIME‑completeness for context‑bounded runs and 2EXPTIME‑completeness for phase‑bounded runs when the bound is part of the input, and clarifies the impact of stack ordering. These contributions advance both the theoretical understanding of pushdown‑based verification and provide guidance for building practical verification tools for concurrent recursive software.