On complexity of propositional Linear-time Temporal Logic with finitely many variables

TL;DR

This paper demonstrates that the satisfiability and model-checking problems for propositional LTL with a single variable are PSPACE-complete, providing an alternative proof that offers deeper insight into LTL's properties.

Contribution

It presents a modified proof of PSPACE-completeness for LTL with one variable, enhancing understanding of its semantic and computational aspects.

Findings

PSPACE-completeness holds for LTL with one variable

Modified proof offers new insights into LTL complexity

Results align with those for multiple variables

Abstract

It is known [DemriSchnoebelen02] that both satisfiability and model-checking problems for propositional Linear-time Temporal Logic, LTL, with only a single propositional variable in the language are PSPACE-complete, which coincides with the complexity of these problems for LTL with an arbitrary number of propositional variables [SislaClarke85]. In the present paper, we show that the same result can be obtained by modifying the original proof of SPACE-hardness for LTL from [SislaClarke85]; i.e., we show how to modify the construction from [SislaClarke85] to model the computations of polynomially-space bound Turing machines using only formulas of one variable. We believe that our alternative proof of the results from [DemriSchnoebelen02] gives additional insight into the semantic and computational properties of LTL.

Equations

$$\varphi::=p\mid\ \perp\ \mid(\varphi\rightarrow\varphi)\mid\!\raisebox{-0.86108pt}{ \mbox{\begin{picture}(2.0,2.0) \put(1.0,1.0){\circle{2.0}} \end{picture}}}\,\varphi\mid(\varphi\hskip 2.0pt\mathcal{U}\varphi),$$

$$\psi ={\psi }_{start}\wedge \square {\psi }_{\delta }\to ◊{\psi }_{positive}.$$

Full text

1 Introduction

The propositional Linear-time Temporal Logic LTL, proposed in [10], is historically the first temporal logic to have been used in formal specification and verification of (parallel) non-terminating computer programs [7], such as (components of) operating systems. It has stood the test of time, despite a dizzying variety of temporal logics that have since been introduced for the purpose (see, e.g., [3]).

The task of verifying that a program conforms to a specification can be carried out by checking whether an LTL formula expressing the specification is satisfied in the structure modelling the execution paths of the program. This corresponds to the model checking problem for LTL: given a formula, a model, and a state, check if the formula is satisfied by all paths of the model beginning with the given state. The related task of verifying that a specification of a program is consistent—and, thus, can be satisfied by some program—corresponds to the satisfiability problem for LTL: given a formula, check whether there is a model and a path satisfying the formula.

Therefore, the complexity of both satisfiability and model checking are of crucial interest when it comes to applications of LTL to formal specification and verification. It has been shown in [14] that both satisfiability and model checking for LTL are PSPACE-complete. It might have been hoped that the complexity of satisfiability, as well as of model checking, may be reduced if we consider a language with only a finite number of propositional variables, which is sufficient for most applications—as has been observed in [4], most properties of interest can be specified using a very small number of variables; typically, not more than three. Indeed, examples are known of logics whose satisfiability problem goes down from “intractable” to “tractable” once we place a limit on the number of propositional variables allowed in the language: thus, satisfiability for the classical propositional logic and all the normal extensions of the modal logic K5 [8], including logics such as K45, KD45, and S5 (see also [6]), used in formal specification and verification of distributed and multi-agent systems [5], goes down from NP-complete to polynomial-time decidable once we limit the number of propositional variables by an (arbitrary) finite number. Similarly, as follows from [9], satisfiability for the intuitionistic propositional logic goes down from PSPACE-complete to polynomial-time if we allow only a single propositional variable in the language.

It has been shown in [4], however, that even a single variable in the language of LTL is sufficient to produce a fragment whose model-checking and satisfiability problems are as hard as corresponding problems for the entire logic. Thus, the complexity of these tasks for LTL cannot be lowered by placing restrictions on the number of variables allowed in the construction of formulas.

It is often instructive to have various proofs of important formal results, to which we believe the results on complexity of model-checking and satisfiability for LTL undoubtedly belong. Thus, in the present paper, we present an alternative proof, which is, in fact, a modification of the original proof from [14] establishing PSPACE-hardness of LTL with an unlimited number of variables. We show that, with some ingenuity, one can modify the construction used in [14] of an LTL-model based on a computation of a polynomially-space bound Turing machine so that we obtain a model for a single-variable fragment of LTL. The interesting feature of a modified construction is that—even though the size of the model, and the LTL-formula describing it, blows up—the blow-up is proportionate to the size of the Turing machine, which is independent of the size of the input, and thus the reduction remains polynomial.

It is worth noticing that most well-know general methods [6, 1, 12, 13, 11] of establishing similar results for modal and temporal logics are not applicable to LTL due to the restiction on the branching factor in its models.

The paper is structured as follows. In section 2, we briefly recall the syntax and semantics of LTL. In section 3, we present our proof of PSPACE-hardness of model-checking and satisfiability problems for the single-variable fragment of LTL, which is a modification of the construction from the original proof from [14]. We conclude in section 4 by drawing attention to some features of LTL that make it stand apart from other modal and temporal logics used in formal specification and verification.

2 Syntax and semantics

The language of LTL contains an infinite set of propositional variables $\textit{{Var}}=\linebreak\{p_{1},p_{2},\ldots\}$, the Boolean constant $\perp$ (“falsehood”), the Boolean connective $\rightarrow$ (“if …, then …”), and the temporal operators   (“next”) and $\hskip 2.0pt\mathcal{U}$ (“until”). The formulas are defined by the following Backus-Naur form expression:

[TABLE]

where $p$ ranges over Var. We also define $\top:=({\perp}\rightarrow{\perp})$, $\neg\varphi:=(\varphi\rightarrow{\perp})$, $(\varphi\wedge\psi):=\neg(\varphi\rightarrow\neg\psi)$, $\Diamond\varphi:=(\top\hskip 2.0pt\mathcal{U}\varphi)$, and $\Box\varphi:=\neg\Diamond\neg\varphi$. We adopt the usual conventions about omitting parentheses. For every formula $\varphi$ and every number $n$ such that $n\geqslant 0$, we inductively define the formula \!\raisebox{-0.86108pt}{ \mbox{\begin{picture}(2.0,2.0) \put(1.0,1.0){\circle{2.0}} \end{picture}}}\,^{n}\varphi as follows: \!\raisebox{-0.86108pt}{ \mbox{\begin{picture}(2.0,2.0) \put(1.0,1.0){\circle{2.0}} \end{picture}}}\,^{0}\varphi:=\varphi, and \!\raisebox{-0.86108pt}{ \mbox{\begin{picture}(2.0,2.0) \put(1.0,1.0){\circle{2.0}} \end{picture}}}\,^{n+1}\varphi:=\!\raisebox{-0.86108pt}{ \mbox{\begin{picture}(2.0,2.0) \put(1.0,1.0){\circle{2.0}} \end{picture}}}\,\!\raisebox{-0.86108pt}{ \mbox{\begin{picture}(2.0,2.0) \put(1.0,1.0){\circle{2.0}} \end{picture}}}\,^{n}\varphi.

Formulas are evaluated in Kripke models (often referred to as “transition systems”). A Kripke model is a tuple $\mathfrak{M}=(\mathcal{S},\longmapsto,V)$, where $\mathcal{S}$ is a non-empty set (of states), $\longmapsto$ is a binary (transition) relation on $\mathcal{S}$ that is serial (i.e., for every $s\in\mathcal{S}$, there exists $s^{\prime}\in\mathcal{S}$ such that $s\longmapsto s^{\prime}$), and $V$ is a (valuation) function $V:\textit{{Var}}\rightarrow 2^{\mathcal{S}}$.

An infinite sequence $s_{0},s_{1},\ldots$ of states of $\mathfrak{M}$ such that $s_{i}\longmapsto s_{i+1}$, for every $i\geqslant 0$, is called a path. Given a path $\pi$ and some $i\geqslant 0$, we denote by $\pi[i]$ the $i$th element of $\pi$ and by $\pi[i,\infty]$ the suffix of $\pi$ beginning with its $i$th element.

Formulas are evaluated with respect to paths. The satisfaction relation between models $\mathfrak{M}$, paths $\pi$, and formulas $\varphi$ is defined inductively, as follows:

• •

$\mathfrak{M},\pi\models p_{i}$ $\leftrightharpoons$ $\pi[0]\in V(p_{i})$;

• •

$\mathfrak{M},\pi\models\bot$ never holds;

• •

$\mathfrak{M},\pi\models(\varphi_{1}\rightarrow\varphi_{2})$ $\leftrightharpoons$ $\mathfrak{M},\pi\models\varphi_{1}$ implies $\mathfrak{M},\pi\models\varphi_{2}$;

• •

\mathfrak{M},\pi\models\!\raisebox{-0.86108pt}{ \mbox{\begin{picture}(2.0,2.0) \put(1.0,1.0){\circle{2.0}} \end{picture}}}\,\varphi_{1} $\leftrightharpoons$ $\mathfrak{M},\pi[1,\infty]\models\varphi_{1}$;

• •

$\mathfrak{M},\pi\models\varphi_{1}\hskip 2.0pt\mathcal{U}\varphi_{2}$ $\leftrightharpoons$ $\mathfrak{M},\pi[i,\infty]\models\varphi_{2}$, for some $i\geqslant 0$, and $\mathfrak{M},\pi[j,\infty]\models\varphi_{1}$ for every $j$ such that $0\leqslant j<i$.

A formula is satisfiable if it is satisfied by some path of some model. A formula is valid if it is satisfied by every path of every model.

We now state the two computational problems considered in the following section. The *satisfiability problem for *LTL: given a formula $\varphi$, determine whether there exists a model $\mathfrak{M}$ and a path $\pi$ in $\mathfrak{M}$ such that $\mathfrak{M},\pi\models\varphi$. The *model-checking problem for *LTL: given a formula $\varphi$, a model $\mathfrak{M}$, and a state $s$ in $\mathfrak{M}$, determine whether $\mathfrak{M},\pi\models\varphi$ for every path $\pi$ such that $\pi[0]=s$. Clearly, formula $\varphi$ is valid if, and only if, $\neg\varphi$ is not satisfiable; thus any deterministic algorithm that solves the satisfiability problem also solves the validity problem, and vice versa.

3 Complexity of satisfiability and model-checking for

finite-variable fragments

In this section, we show how the original construction used in  [14] to establish PSPACE-hardness of model-checking and satisfiability for LTL with an arbitrary number of propositional variables can be modified to prove that model-checking and satisfiability for the single-variable fragments of LTL are PSPACE-hard, too. Before doing so, we briefly note that, for the variable-free fragment, both problems are polynomially decidable. Indeed, it is easy to check that every variable-free LTL formula is equivalent to either $\perp$ or $\top$ (for example, ${\top}\hskip 2.0pt\mathcal{U}{\top}$ is equivalent to $\top$ and ${\top}\hskip 2.0pt\mathcal{U}{\perp}$ is equivalent to $\perp$); thus, to check for satisfiability of a variable-free formula $\varphi$, all we need to do is to recursively replace each subformula of $\varphi$ by either $\perp$ or $\top$, which is linear in the size of $\varphi$; likewise for model-checking.

We recall that in [14] an arbitrary problem “$x\in A?$” solvable by polynomially-space bounded (deterministic) Turing machines is reduced to model-checking for LTL. (The authors of [14] then reduce the model-checking problem for LTL to the satisfiability problem for LTL.) We show how one can modify the construction from [14] to simultaneously reduce the problem “$x\in A?$” to both model checking and satisfiability for LTL using formulas containing only one variable. Since we are describing a modification of a well-known construction, we will be rather brief. As we go along, we point out the main differences of our construction from that in [14].

Let $M=(Q,\Sigma,q_{0},q_{1},a_{0},a_{1},\delta)$ be a (deterministic) Turing machine, where $Q$ is the set of states, $\Sigma$ is the alphabet, $q_{0}$ is the starting state, $q_{1}$ is the final state, $a_{0}$ is the blank symbol, $a_{1}$ is the symbol marking the leftmost cell, and $\delta$ is the machine’s program. We adopt the convention that $M$ gives a positive answer if, at the end of the computation, the tape is blank save for $a_{0}$ written in the leftmost cell. We assume, for technical reasons, that $\delta$ contains an instruction to the effect that the “yes” configuration yields itself (thus, we assume that all computations with a positive answer are infinite). Given an input on length $n$, we assume that the amount of space $M$ uses is $S(n)$, for some polynomial $S$.

We now construct, in time polynomial in the size of $x$, a model $\mathfrak{M}$, a path $\pi$ in $\mathfrak{M}$, and a formula $\psi$—of a single variable, $p$—such that $x\in A$ if, and only if, $\mathfrak{M},\pi\models\varphi$. It will also be the case that $x\in A$ if, and only if, $\psi$ is LTL-valid. The model $\mathfrak{M}$ intuitively corresponds, in the way described below, to the computation of $M$ on input $x$.

First, we need the ability to model natural numbers within a certain range, say $1$ through $k$. To that end, we use models based on the frame $\mathfrak{F}_{k}$, depicted in Figure 1, which is a line made up of $k$ states. By making $p$ true exactly at the $i$th state of $\mathfrak{F}_{k}$, where $1\leqslant i\leqslant k$, we obtain a model representing the natural number $i$. We denote the model representing the number $m$ by $\mathfrak{N}_{m}$.

We next use models $\mathfrak{N}_{m}$ to build a model representing all possible contents of a single cell of $M$. Let $|Q|=n_{1}$ and $|\Sigma|=n_{2}$. As each cell of $M$ may contain either a symbol from $\Sigma$ or a sequence $qa$, where $q\in Q$ and $a\in\Sigma$, indicating that $M$ is scanning the present cell, where $a$ is written, there are $n_{2}\times(n_{1}+1)$ possibilities for the contents of a single cell of $M$. Let $k=n_{2}\times(n_{1}+1)$; clearly, $k$ is independent of the size of the input $x$. To model the contents of a single cell, we use models $\mathfrak{N}_{1}$ through $\mathfrak{N}_{k}$ to build a model $\mathfrak{C}$, depicted in Figure 2, where small boxes represent models $\mathfrak{N}_{1}$ through $\mathfrak{N}_{k}$. In Figure 2, an arrow from $s_{0}$ to a box corresponding to the model $\mathfrak{N}_{m}$ represents a transition from $s_{0}$ to the first state of $\mathfrak{N}_{m}$, and an arrow from a box corresponding to the model $\mathfrak{N}_{m}$ to $s_{1}$ represents a transition from the last state of $\mathfrak{N}_{m}$ to $s_{1}$. On the states in $\mathfrak{N}_{m}$ ($1\leqslant m\leqslant k$), the evaluation of $p$ in $\mathfrak{C}$ agrees with the evaluation of $p$ in $\mathfrak{N}_{m}$; in addition, $p$ is false both at $s_{0}$ and $s_{1}$.

Let the length of $x$ be $n$. We use $S(n)$ copies of $\mathfrak{C}$ to represent a single configuration of $M$. This is done with the model $\mathfrak{M}$, depicted in Figure 3. In $\mathfrak{M}$, a chain made up of $S(n)$ copies of $\mathfrak{C}$ is preceded by a model $\mathfrak{B}$ marking the beginning of a configuration; the use of $\mathfrak{B}$ allows us to separate configurations from each other. All that is required of the shape of $\mathfrak{B}$ is for it to contain a pattern of states (with an evaluation) that does not occur elsewhere in $\mathfrak{M}$; thus, we may use the frame $\mathfrak{F}_{3}$ and define the evaluation to make $p$ true at its every state.

This completes the construction of the model $\mathfrak{M}$. One might think of $\mathfrak{M}$ as consisting of “cycles,” each cycle representing a single configuration of $M$ in the following way: to obtain a particular configuration of $M$, pick a path from the first state of $\mathfrak{B}$ to the last state of the last copy of $\mathfrak{C}$ that traverses the model $\mathfrak{N}_{i}$ withing the $j$th copy of $\mathfrak{C}$ exactly when the $j$th cell of the tape of $M$ contains the $i$th “symbol” from the alphabet $\Sigma\,\cup\,Q\times\Sigma$.

The main, and crucial, difference between the model $\mathfrak{M}$ described above and the model used in [14] is that we use “components” $\mathfrak{N}_{k}$ where [14] use an anti-chain of $k$ states distinguished by the evaluation of $k$ distinct propositional variables. This allows us—in contrast to [14]—to use a single propositional variable in describing our model.

We now describe how to build a formula $\psi$ whose satisfaction we want to check with respect to an infinite path beginning with the first state of $\mathfrak{B}$. It is rather straightforward to write out the following formulas (all one needs to say is what symbols are written in each of the cells of $M$’s tape):

• •

A formula $\psi_{start}$ describing the initial configuration of $M$ on $x$;

• •

A formula $\psi_{positive}$ describing the configuration of $M$ corresponding to the positive answer.

The length of both $\psi_{start}$ and $\psi_{positive}$ is clearly proportionate to $k\times S(n)$, as we have $S(n)$ cells to describe and use formulas of length proportionate to $k$ to describe each of them. Next, we can write out a formula $\psi_{\delta}$ describing the program $\delta$ of $M$. This can be done by starting with formulas of the form \!\raisebox{-0.86108pt}{ \mbox{\begin{picture}(2.0,2.0) \put(1.0,1.0){\circle{2.0}} \end{picture}}}\,^{j}\sigma, where $j$ is the number of states in a path leading from the first state of $\mathfrak{B}$ to the last state of the last copy of $\mathfrak{C}$ in a single “cycle” in $\mathfrak{M}$, to describe the change in the contents of the cells from one configuration to the next, and then, for each instruction $I$ from $\delta$, writing a formula $\alpha(I)$ of the form $\bigwedge_{i=0}^{S(n)}\Box\chi$, where $\chi$ describes changes occurring in each cell of $M$. Clearly, the length of each $\alpha(I)$ is proportionate to $k\times S(n)$. Then, $\psi_{\delta}=\bigwedge_{I\in\delta}\alpha(I)$. As the number of instructions in $\delta$ is independent from the length of the input, the length of $\psi_{\delta}$ is proportionate to $c\times S(n)$, for some constant $c$.

Lastly, we define

[TABLE]

One can then show, by induction on the length of the computation of $M$ on $x$, that $M(x)=yes$ if, and only if, $\psi$ is satisfied in $\mathfrak{M}$ by an infinite path corresponding, in the way described above, to the computation of $M$ on $x$. This gives us the following:

Theorem 3.1

*The model-checking problem for LTL formulas with at most one variable is *PSPACE-complete.

Likewise, we can show that $M(x)=yes$ if, and only if, $\psi$ is satisfiable, which gives us the following:

Theorem 3.2

*The satisfiability problem for LTL formulas with at most one variable is *PSPACE-complete.

4 Conclusion

We have shown how the construction from [14] can be modified to prove the PSPACE-hardness of both model-checking and satisfiability for the single-variable fragment of the propositional Linear-time Temporal Logic, LTL. The essential difference between the original construction and the modified construction presented above is that we use chains of states of length $n_{2}\times(n_{1}+1)$, where $n_{1}$ and $n_{2}$ are the number of states and symbols, respectively, of the Turing machine whose computation we model, rather than single states used in [14] to evaluate $n_{2}\times(n_{1}+1)$ variables. Since numbers $n_{1}$ and $n_{2}$ are not known in advance, the modelling in [14] requires an unlimited number of variables. In our modification of the proof from [14], the number $n_{2}\times(n_{1}+1)$ is reflected in the model that can be described by formulas with a single variable, thus producing a reduction to a single-variable formula. Even though the length of the formula is clearly dependent on $n_{2}\times(n_{1}+1)$, this number is independent of the input $x$ to the problem “$x\in A?$” which we are reducing to the model-checking and satisfiability for LTL; thus, the reduction remains polynomial. This is a rather curious property of LTL, which makes it stand apart from most “natural” modal and temporal logics (by a “natural” logic, we mean a logic that was not purposefully constructed to exhibit a certain property).

We conclude by drawing attention to another peculiarity of LTL that makes it stand apart from other “natural” modal and temporal logics. While the complexity function (see [2], Section 18.1) for LTL, both in the language with infinitely many variables, and—as follows from the proof presented above, in the language with a single variable—is polynomial, the complexity of the corresponding satisfiability problem is PSPACE-complete. By contrast, for most “natural” modal and temporal logics, the polynomiality of the complexity function implies the polynomial-time decidable satisfiability problem, and PSPACE-completeness of satisfiability problem implies the exponential complexity function.