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 onecounter automata (where counter increments and decrements are integers written in binary) is EXPSPACEhard. 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 EXPSPACEhardness of reachability games on succinct onecounter nets (with no zero tests).
Simulationlike equivalences on (nonsuccinct) onecounter nets are PSPACEcomplete (see [3] for simulation equivalence and [1] for bisimulation equivalence). This immediately yields EXPSPACEupper 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 PSPACElower 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 blowup.”
Here, in this paper, we close the complexity gap by showing EXPSPACEhardness (and thus EXPSPACEcompleteness), using a defenderchoice 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 EXPSPACEhardness of reachability games. (This makes our paper selfcontained 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 PSPACEhardness for emptiness of alternating finite automata with oneletter alphabet (thus giving an alternative proof for the result by Holzer [4]); Srba [10] used this result to show PSPACEhardness of behavioural relations for (nonsuccinct) onecounter 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 EXPTIMEcomplete problem, by a slight enhancement we get an EXPSPACEcomplete problem.
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 onecounter 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 defenderchoice technique (with two synchronously evolving copies of the respective onecounter automaton).
Performing the above sketched procedure to prove the mentioned results rigorously would require recalling technical details from [2]. Instead we give a direct selfcontained proof, which also makes clear that our results do not rely on the involved complexity results used in [2].
EXPSPACEhardness 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 onecounter automaton, with Eve’s and Adam’s control states one of which is Eve’s winning state; there are no zerotests 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 headposition 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 tapesymbol 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 defenderchoice technique is used when there is Adam’s turn. To this aim the two automatoncopies are a bit enhanced and interconnected (as in Fig. 2, discussed later). By performing a “choiceaction” 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 automatoncopy). 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).
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 rgame 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:

if , , and for some , then ;

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 rankreducing if . We note that for any with we have: if , then there is at least one rankreducing transition (in, fact in this case); if , then there is at least one transition and all such transitions are rankreducing.
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 rgames and LTSs, presented by particular onecounter automata.
(Succinct) onecounter net games.
By a onecounter net game, an ocngame 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 ocngame has the associated rgame
(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 RGSOCN (reachability game on succinct onecounter nets):
Instance: an ocngame 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 onecounter nets.
A labelled onecounter 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) onecounter net, a SOCN for short, as an OCN where the integers in rules are written in binary.
4 EXPSPACEhardness of reachability games
In Section 2 we sketched a “master” reduction showing EXPSPACEhardness of reachability games on succinct onecounter nets, which is captured by the following theorem.
The problem is EXPSPACEhard.
As already mentioned, an idea of a proof is given in [5] by referring to [2]. Here we provide a selfcontained proof, by performing the sketched master reduction in detail.
We first give a construction for general Turing machines, and then implement its spacebounded variant by onecounter 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 tapesymbol , 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 headposition; if for the headposition (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 rgame
where , , , and where the transition relation is defined as follows:

Eve’s moves:

for all ;

if and ;

if .


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 onecounter 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 headposition 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 headposition is kept inside . Our aim is to mimic by (the rgame associated with) an ocngame ; 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 ocngame given by the rules in (3) does not mimic the game faithfully, due to possible “cheating” related to the boundary headpositions. Therefore we add
(4) 
for the cases . By entering a configuration Eve also “claims” that the headposition 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 headposition 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 ocngame
(9) 
where

,

(recall that ), and the set of rules is given by (3), (4), (5), (6), (7), (8).
In the rgame associated with we have iff the computation of on never moves the head out of and finishes with accepting.
Proof.
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 counterdecrements , (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 headposition 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 workspace (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) onecounter nets.
We assume a (general) rgame , and below we define the LTS
(10) 
(Cf. Fig. 1 and 2, where we now ignore the bracketed parts of transitionlabels.)
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 ); 
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:

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

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 rankreducing transition. Attacker’s move , from the pair
Comments
There are no comments yet.