EXPSPACE-hardness of behavioural equivalences of succinct one-counter nets

01/03/2018 ∙ by Petr Jancar, et al. ∙ Association for Computing Machinery 0

We note that the remarkable EXPSPACE-hardness result in [Göller, Haase, Ouaknine, Worrell, ICALP 2010] ([GHOW10] for short) allows us to answer an open complexity question for simulation preorder of succinct one counter nets (i.e., one counter automata with no zero tests where counter increments and decrements are integers written in binary). This problem, as well as bisimulation equivalence, turn out to be EXPSPACE-complete. The technique of [GHOW10] was referred to by Hunter [RP 2015] for deriving EXPSPACE-hardness of reachability games on succinct one-counter nets. We first give a direct self-contained EXPSPACE-hardness proof for such reachability games (by adjusting a known PSPACE-hardness proof for emptiness of alternating finite automata with one-letter alphabet); then we reduce reachability games to (bi)simulation games by using a standard "defender-choice" technique.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

We concentrate on our contribution, without giving a broader overview of the area here.

A remarkable result by Göller, Haase, Ouaknine, Worrell [2] shows that model checking a fixed CTL formula on succinct one-counter automata (where counter increments and decrements are integers written in binary) is EXPSPACE-hard. Their proof is interesting and nontrivial, and uses two involved results from complexity theory. The technique of this proof was (a bit vaguely) referred to by Hunter [5], by which he derived EXPSPACE-hardness of reachability games on succinct one-counter nets (with no zero tests).

Simulation-like equivalences on (non-succinct) one-counter nets are PSPACE-complete (see [3] for simulation equivalence and [1] for bisimulation equivalence). This immediately yields EXPSPACE-upper bounds in the “succinct” cases.

The PSPACE—EXPSPACE gap for the simulation problem was also mentioned in [3] from where we quote: “Another direction for further research is to establish the exact complexity of strong/weak simulation for OCN with binary encoded increments and decrements on the counter. Trivially, the PSPACE-lower bound applies for this model and an EXPSPACE upper bound follows from the results of this paper with the observation that these more expressive nets can be unfolded into ordinary OCN with an exponential blow-up.”

Here, in this paper, we close the complexity gap by showing EXPSPACE-hardness (and thus EXPSPACE-completeness), using a defender-choice technique (cf., e.g., [7]) to reduce reachability games to any relation between simulation preorder and bisimulation equivalence.

But we first present a direct proof of EXPSPACE-hardness of reachability games. (This makes our paper self-contained and shows that we do not need to rely on the result from [2].) Our direct proof is based on the technique from [6] used there to show PSPACE-hardness for emptiness of alternating finite automata with one-letter alphabet (thus giving an alternative proof for the result by Holzer [4]); Srba [10] used this result to show PSPACE-hardness of behavioural relations for (non-succinct) one-counter nets. In Section 6 we discuss a relation of our proof to the countdown games of [8] and their use in [9]. While the countdown games can serve as an interesting EXPTIME-complete problem, by a slight enhancement we get an EXPSPACE-complete problem.

We stress that we do not provide an alternative proof for the EXPSPACE-hardness result in [2]; the result in [2] is stronger, though technically it does not induce the hardness results for reachability and (bi)simulation games automatically.

In Section 2 we give an informal overview of the ideas in our paper. Section 3 contains formal definitions, Section 4 proves the EXPSPACE-hardness of reachability games, and Section 5 reduces reachability games to (bi)simulation games. Section 6 contains some additional remarks.

2 Informal overview

The mentioned strong result in [2] shows that for any fixed language in EXPSPACE we can for any word (in the alphabet of ) construct a succinct one-counter automaton that performs a computation which is accepting iff . Such a computation needs to access concrete bits in the (reversed) binary presentation of the counter value. A straightforward direct access to such bits is destructive (the counter value is lost after the bit is read) but this can be avoided: instead of a “destructive reading” the computation just “guesses” the respective bits, and it is forced to guess correctly by a carefully constructed CTL formula that is required to be satisfied by the computation.

If we imagine that there is an opponent who can challenge the guesses about bits, and after a challenge a destructive test follows that either confirms the guess or exposes its invalidity, then this readily leads to the hardness results for reachability games, and then also for behavioural relations by using a defender-choice technique (with two synchronously evolving copies of the respective one-counter automaton).

Performing the above sketched procedure to prove the mentioned results rigorously would require recalling technical details from [2]. Instead we give a direct self-contained proof, which also makes clear that our results do not rely on the involved complexity results used in [2].

EXPSPACE-hardness of reachability games

We use a “master” reduction. We thus fix an arbitrary language

in EXPSPACE, decided by a Turing machine

in space for a fixed polynomial . For any word in the alphabet of there is the respective computation of , which is accepting iff ; the computation is a sequence of configurations, each being a string of length .

Any can code the -th position in where ( is integer division) and (assuming ). Given , we can construct an alternating one-counter automaton, with Eve’s and Adam’s control states one of which is Eve’s winning state; there are no zero-tests but transitions yielding negative counter values are not allowed. Starting in the initial configuration (with zero in the counter), Eve (who claims that there is an accepting computation ) keeps incrementing the counter until she enters a configuration by which she claims that the position coded by is the head-position in the accepting configuration and contains letter ( being the accepting state of ).

Eve then subtracts and enters a control state corresponding to a triple of symbols that she claims to be the -th, the -th, and the -th symbol in (where ); the triple must be consistent with the current symbol and the transition rules of . We note that at least one symbol (of the type or ) in the triple must be incorrect when is incorrect (i.e., when it is not really the -th symbol in ).

Now Adam chooses a new current symbol from the triple, and also adds to the counter accordingly. Eve then presents another consistent triple, etc.

In fact, Eve can also present a pair instead of a triple, claiming that or that (where ). Adam can challenge this, claiming that or that ; similarly he can claim that or that when Eve provides a triple. Such claims can be easily (destructively) verified: We first let Eve decrement the counter by repeatedly. If she leaves a number in the counter, then Adam uses a transition subtracting that enters a state precluding Eve’s win. Hence Eve is rather subtracting until is in the counter. Similarly we implement the respective checks of the claims , , , so that Eve can force her win precisely when her claim was correct.

Finally, Eve can claim that has been reached (i.e., ), which can be again punished by Adam if not true. In the case Eve wins if the control state “claims” the -th symbol of (for ), which is the blank tape-symbol if ; checking this condition can be again easily implemented in the game.

Hence iff Eve can force reaching her winning control state (when starting in ).

Reachability game reduces to (bi)simulation game

Given a (succinct) one counter automaton with Eve’s and Adam’s control states, one of them being Eve’s winning, we first label each transition by its unique action (action name) and take two copies of the resulting automaton (control state in one copy has a counterpart in the other); in the first copy we add a special (“winning”) action in Eve’s winning state.

We let two players, called Attacker and Defender, to mimic the reachability game. If there is Eve’s turn, Attacker performs a transition in one copy, and Defender must do the same in the other copy, being obliged to use the same action as Attacker (cf. Fig 1).

The defender-choice technique is used when there is Adam’s turn. To this aim the two automaton-copies are a bit enhanced and interconnected (as in Fig. 2, discussed later). By performing a “choice-action” Attacker lets Defender to choose from (more than one) transitions labelled with ; if Attacker does not follow Defender’s choice in the next round, then Defender installs syntactic equality (in which case the play continues from a pair of the same configurations of the same automaton-copy). It is thus Defender who chooses Adam’s moves.

By the above construction we achieve that if Eve has a winning strategy in the reachability game from , then is not simulated by , and if Eve has no winning strategy, then and are bisimilar (in the respective labelled transition system).

Figure 1: In it is Attacker who chooses or .

.

Figure 2: In it is Defender who chooses or (or a pair of equal states); to take the counter-changes into account correctly, we put , , and , (hence and ).

.

3 Definitions

By we denote the set of integers, and by the set of nonnegative integers .
We use for denoting the set , where .

Reachability games.

By a reachability game, or an r-game for short, we mean a tuple , where is the set of states (or vertices), is the set of Eve’s states, is the transition relation (or the set of transitions), and is the set of target states. By Adam’s states we mean the elements of .

We put where is the class of ordinals and the sets are defined inductively as follows. We put . For we put , and we stipulate:

  1. if , , and for some , then ;

  2. if , , and we have , then .

(If a) applies, then is surely a successor ordinal, otherwise can be also a limit ordinal.)

For each , by we denote (the unique) such that . A transition is rank-reducing if . We note that for any with we have: if , then there is at least one rank-reducing transition (in, fact in this case); if , then there is at least one transition and all such transitions are rank-reducing.

Remark. We are primarily interested in the games that have (at most) countably many states and are finitely branching (the sets are finite for all ). In such cases we have for each .
We also note that is the set of states from which Eve has a winning strategy, i.e. such that guarantees reaching (some state in) when Eve is choosing a next transition in Eve’s states and Adam is choosing a next transition in Adam’s states.

Labelled transition systems and (bi)simulations.

A labelled transition system, an LTS for short, is a tuple where is the set of states, is the set of actions, and is the set of -transitions (transitions labelled with ), for each .

Given , a relation is a simulation if for every and every there is such that ; if, moreover, for every and every there is such that , then is a bisimulation. The union of all simulations (on ) is the maximal simulation, denoted ; it is a preorder, called simulation preorder. The union of all bisimulations is the maximal bisimulation, denoted ; it is an equivalence, called bisimulation equivalence (or bisimilarity). We observe that .

Remark. We can write or also for states , from different LTSs , , in which case the LTS arising by the disjoint union of and is (implicitly) referred to.
It is also useful to think in terms of games here. In the simulation game, in a (current) pair Attacker chooses a transition and Defender responds with some (for the action chosen by Attacker); the play then continues with another round, now in the current pair , etc. If Defender has no response in a round, then Attacker wins the play. It is standard to note that iff Attacker has a winning strategy from .
The case of bisimulation game is analogous, but in any round starting from Attacker can choose to play or , and Defender has to respond with some or , respectively. Now Attacker has a winning strategy from iff .

We now define specific r-games and LTSs, presented by particular one-counter automata.

(Succinct) one-counter net games.

By a one-counter net game, an ocn-game for short, we mean a tuple where is the finite set of (control) states, is the set of Eve’s (control) states, is the target (control) state, and is the finite set of (transition) rules. We often present a rule as . By Adam’s (control) states we mean the elements of .

An ocn-game has the associated r-game

(1)

where iff is a rule (in ). We often write instead of for states of . (A rule thus induces transitions for all .)

We define the problem RG-SOCN (reachability game on succinct one-counter nets):

Instance: an ocn-game with integers in rules written in binary,
              and a control state .
Question: Is in the game  ?

Remark. We have defined the target states (in ) by the control state . There are other natural variants (e.g., one in [5] defines the target set ) that are, in principle, equivalent in our context.

(Succinct) labelled one-counter nets.

A labelled one-counter net, an OCN for short, is a triple , where is the finite set of control states, the finite set of actions, and is the finite set of (labelled transition) rules. We present a rule as (, ). An OCN has the associated LTS

(2)

where iff is a rule in . (We again write instead of . A rule thus induces transitions for all .)

For claims on complexity (in particular for Theorem 5) we define a succinct (labelled) one-counter net, a SOCN for short, as an OCN where the integers in rules are written in binary.

4 EXPSPACE-hardness of reachability games

In Section 2 we sketched a “master” reduction showing EXPSPACE-hardness of reachability games on succinct one-counter nets, which is captured by the following theorem.

The problem is EXPSPACE-hard.

As already mentioned, an idea of a proof is given in [5] by referring to [2]. Here we provide a self-contained proof, by performing the sketched master reduction in detail.

We first give a construction for general Turing machines, and then implement its space-bounded variant by one-counter nets. Hence we now fix an arbitrary (deterministic) Turing machine , where is the set of (control) states, the initial state, the accepting state, the rejecting state, the input alphabet, the tape alphabet, satisfying for the special blank tape-symbol , and is the transition function.

Putting , we define the relation in a standard way:
if for at most one and the following conditions hold:

  • if and , then if and otherwise (i.e., if );

  • if and , then (for any );

  • if and , then if and otherwise;

  • if , then .

We note that is a partial function, in fact. By a configuration of we mean a mapping where for only finitely many and for precisely one , called the head-position; if for the head-position (and ) then is accepting, and if then is rejecting.

We put (thus overloading the symbol ) if for all . This relation is again a partial function; if is final, i.e. accepting or rejecting, then there is no such that .

Given a word (hence ), we define the respective initial configuration as where if and if , for all , and for all and all . If is not final, then we define so that . The computation on is either the finite sequence where is final (accepting or rejecting), or the infinite sequence ; formally we put (for ) if there is a final and .

By we denote the language accepted by , i.e. the set the computation on finishes with an accepting configuration.

Given (our fixed) Turing machine and a word , we define the r-game

where , , , and where the transition relation is defined as follows:

  1. Eve’s moves:

    1. for all ;

    2. if and ;

    3. if .

  2. Adam’s moves: for .

The next proposition shows how Eve’s winning region is related to ’s computation on .

In we have where

  • if and if ,

  • ,

  • .

Proof.

By definition we have . We first ignore the question if , and show the rest of the claim by induction on . The base case () is clear due to the transitions from the points 1c) and 2). The induction step is also easy to check, when we note that for any with we have:

  • if then there is a transition such that
    , and

  • if then for every transition there is such that .

The claim for follows, since iff for some , , . ∎

If we think of mimicking the game by a one-counter game, it is natural to represent a state , or , so that , or , is (in) a control state and is suitably represented by one (counter) value . This seems manageable when we are guaranteed that in the computation of on the head-position is never outside for a fixed ; we now assume this, while also assuming for convenience. In such a case can be naturally adjusted to yield a game in which the head-position is kept inside . Our aim is to mimic by (the r-game associated with) an ocn-game ; a first attempt to built such can look as follows:

(3)

By the configuration we represent the state of . A configuration is intended to represent the state ; similarly is intended to represent the state . Hence and are Eve’s control states, while are Adam’s control states.

The ocn-game given by the rules in (3) does not mimic the game faithfully, due to possible “cheating” related to the boundary head-positions. Therefore we add

(4)

for the cases . By entering a configuration Eve also “claims” that the head-position is , i.e., that . The state is Adam’s, who can believe the claim and play accordingly, or decide to challenge the claim by performing . Symmetrically we add

(5)

for the cases . By entering a configuration Eve also claims that the head-position is , i.e., that . In a state Adam can decide to challenge the claim by performing .

To complete this reasoning, by entering (with no superscript) Eve claims that ; Adam can challenge this by using one of the rules

(6)

Hence control states , for , can be viewed as Adam’s claims “the current counter value satisfies ”; similarly is Adam’s claim “”. We need to add some rules guaranteeing Eve’s win in the configurations and precisely when Adam’s claims are incorrect. Moreover, we need that in where Eve can force her win iff . The required properties are achieved by completing the rules (3), (4), (5), (6) with

(7)

and with the following final set:

(8)

Here ranges over two values, and .

Given , , and , we thus constructed the ocn-game

(9)

where

  • ,

(recall that ), and the set of rules is given by (3), (4), (5), (6), (7), (8).

In the r-game associated with we have iff the computation of on never moves the head out of and finishes with accepting.

Proof.

The claim follows by Prop. 4, by the previous discussions accompanying the construction of , and by the following properties that are easy to check (recall that ):

  1. iff ;

  2. iff , and iff ;

  3. iff , and iff ;

  4. for , iff .

Using the rules (7) in when is thus losing for Eve; by this the proof is finished. ∎

We now note that the control states in are determined by , as well as the rules except of those in (7) that are dependent on ; to be precise, the values of counter-decrements , (in for ) and are not determined by but by “parameters” and .

To finish the proof of Theorem 4, we assume an arbitrary fixed language in . There is thus a Turing machine and a polynomial such that decides and the head-position in the computation of on any (in the alphabet of ) never moves out of the interval where for . Given , it is straightforward to construct , by filling the rules (7) and the parameters into a fixed scheme. Since can be presented in binary by using bits, we can construct in logarithmic work-space (from a given ).

5 Reducing reachability games to (bi)simulation games

We first discuss a reduction in a general framework, and then apply it to the case of (succinct) one-counter nets.

We assume a (general) r-game , and below we define the LTS

(10)

(Cf. Fig. 1 and 2, where we now ignore the bracketed parts of transition-labels.)

The set is defined as follows (recall that ):

  • every and its “copy” is in ;

  • if and , then a state is in
    (in Fig. 2 we write, e.g., instead of );

  • if and is nonempty, then a state is in
    (in Fig. 2 we write instead of ).

We put and define for as follows:

  • if and , then and
    (in Fig. 1 we write, e.g., instead of );

  • if and , then

    1. , and , for all
      (cf. Fig. 2 where and and consider dashed edges as normal edges; the subscript in stands for “choice”);

    2. for each we have and ; moreover, for each we have
      (e.g., in Fig. 2 we thus have and ).

  • for each we have (for special that is not performable from ).

We recall that where denotes simulation preorder and bisimulation equivalence.

For any and any relation satisfying we have:

  1. if (in ), then (in ) and thus ;

  2. if , then and thus .

Proof.

a) For the sake of contradiction suppose that there is such that ; we consider such with the least rank. We note that , since entails due to the transition .

If , then let be a rank-reducing transition. Attacker’s move , from the pair