Resolving Nondeterminism by Chance
Abstract
History-deterministic automata are those in which nondeterministic choices can be correctly resolved stepwise: there is a strategy to select a continuation of a run given the next input letter so that if the overall input word admits some accepting run, then the constructed run is also accepting.
Motivated by checking qualitative properties in probabilistic verification, we consider the setting where the resolver strategy can randomise and only needs to succeed with lower-bounded probability. We study the expressiveness of such stochastically-resolvable automata as well as consider the decision questions of whether a given automaton has this property. In particular, we show that it is undecidable to check if a given NFA is -stochastically resolvable. This problem is decidable for finitely-ambiguous automata. We also present complexity upper and lower bounds for several well-studied classes of automata for which this problem remains decidable.
Keywords and phrases:
History-determinism, finite automata, probabilistic automataCopyright and License:
2012 ACM Subject Classification:
Theory of computation Formal languages and automata theoryAcknowledgements:
We would like to thank the anonymous reviewers for their constructive feedback, that helped improve the paper.Funding:
††margin:Editors:
Patricia Bouyer and Jaco van de PolSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Many successful verification techniques rely on automata representations for specifications that capture the languages of acceptable system traces. These automata models are typically nondeterministic: any given trace may give rise to multiple runs of the automaton, and is accepted if at least one of these runs is successful. This enables succinct representations but is also a major source of complexity due to costly intermediate determinisation steps.
It is therefore natural to put extra constraints on the extent to which an automaton allows nondeterministic choice to avoid determinisation. One way to do this is to bound the level of ambiguity: an automaton is -ambiguous if on every accepted word it has at most many distinct accepting runs (see e.g. [42, 35, 16]). Unambiguous automata have proven to be useful for model-checking of Markov chain models [7, 33]. An orthogonal restriction on nondeterminism, which has been extensively studied in recent years (cf. [24, 14, 27, 3, 8, 1, 41, 9, 10, 32, 33]), is to demand that choices can be resolved “on-the-fly”: An automaton is history-deterministic (HD) if there is a strategy to select a continuation of a run given a next letter, so that if the overall word admits some accepting run then the constructed run is also accepting. This condition is strict in the sense that the resolver strategy must guarantee to produce an accepting run if one exists. In some scenarios less strict guarantees may suffice, for example when model-checking Markov Decision Processes [22, 21, 4, 6]. This motivates the study of automata that can be resolved in a weaker sense, namely, where the resolver strategy can randomise and is only required to succeed with a lower-bounded confidence.
A stochastic resolver for some nondeterministic automaton is a function that, for any finite run and input letter, gives a distribution over the possible transitions. This produces a probabilistic automaton that assigns a probability of acceptance to every input word and, together with a threshold , defines the language consisting of all words whose probability of acceptance is at least (see, e.g., [37]). Unless stated otherwise, we will consider memoryless stochastic resolvers, which base their decisions solely on the last state of the given run and the input letter. Fixing a memoryless resolver turns into a probabilistic automaton over the same set of states and where transitions that appear positively in are also contained in . Consequently then, for every threshold , the language is included in that of . We now ask which automata admit positional resolvers that also guarantee the inclusion in the other direction.
An automaton called -memoryless stochastically resolvable (or simply -resolvable) if there exists a memoryless stochastic resolver with . An automaton is positively memoryless stochastically resolvable (or simply positively resolvable) if it is -resolvable for some . By varying the threshold , stochastic resolvability defines a spectrum where -resolvable corresponds to unrestricted nondeterminism and, on finite words, -resolvable coincides with history-determinism. See Figure 1 for distinguishing examples.
Related Work.
The notion of history-determinism was introduced independently, with slightly different definitions, by Henzinger and Piterman [24] for solving games without determinisation, by Colcombet [14] for cost-functions, and by Kupferman, Safra, and Vardi [28] for recognising derived tree languages of word automata. For -regular automata, these variations all coincide [8]. For coBüchi-recognisable languages, history-deterministic automata can be exponentially more succinct than any equivalent deterministic ones [27]. Checking whether a given automaton is HD is decidable in polynomial time for Büchi and coBüchi automata [3, 27] and more generally also for parity automata of any fixed parity index [31]. History-determinism has been studied for richer automata models, such as pushdown automata [32, 20] timed automata [12, 11, 23] and quantitative automata [9, 10].
Recently, and independently from us, Henzinger, Prakash and Thejaswini [25] introduced classes of stochastically resolvable automata. The main difference of their work compared to ours is that they study the qualitative setting, where resolvers are required to succeed almost-surely, with probability one. In the terminology introduced above these are -resolvable automata. They study such automata on infinite words and compare their expressiveness, relative succinctness, against history-deterministic and semantically deterministic automata. Over finite words, these notions coincide: an NFA is -stochastically resolvable iff it is -memoryless stochastically resolvable iff it is semantically deterministic iff it is history-deterministic. They also consider the complexity of determining whether an automaton is -resolvable and establish that this is in polynomial time for safety automata, and -complete for reachability and weak automata, and remains open for more general classes.
For a fixed probabilistic automaton, deciding whether a given is a lower bound corresponds to the undecidable emptiness problem [37], while asking if such a exists relates to the undecidable zero-isolation problem [19]. These problems become more tractable under restrictions such as bounded ambiguity [15, 16, 17, 18]. In the unary case, checking if is a lower bound is equivalent to the long-standing open positivity problem for linear recurrence sequences [36] and is also hard for Markov chains [45]. In contrast, our setting allows the probabilistic automaton to vary, asking whether some choice of probabilities satisfies the desired properties.
The unary case can be seen as a synthesis problem on parametric Markov chains. Consider the distribution transformer perspective [2, 5], where a Markov chain induces a sequence of distributions over states. Then the -resolvability problem asks, for universal NFA, whether there exists a parameter assignment such that the sequence of distributions is “globally” in the semi-algebraic set (distributions with probability mass at least in accepting states). When the NFA is non-universal the “globally” condition must be adjusted to the eventually periodic pattern of the NFA. Existing work characterises, up to a set of measure zero, parameters that satisfy prefix-independent properties or “eventually” properties such as Finally Globally in [5]. For general parametric questions, there is always the special case where the parameters are redundant, which encodes the aforementioned positivity problem [45]. This special case does not necessarily arise in our setting, as the problem has all transitions parameterised independently (only the structure is fixed), which leaves hope for -resolvability.
Our Contributions.
We focus on automata over finite words and consider the decision problems whether a given automaton is resolvable. We distinguish the two variants of this problem, asking whether the automaton is positively resolvable, or whether it is -resolvable for a given value of . Our results are as follows, see also Table 1 for a summary.
-
We introduce the quantitative notion of -memoryless stochastic resolvability, and show -resolvability induces a strict hierarchy of automata with varying parameter .
-
We show that checking -resolvability is undecidable already for NFA, on finite words, and therefore also for automata on infinite words regardless of the accepting condition.
-
We complement this by showing that both positive resolvability and -resolvability remain decidable for finitely-ambiguous automata.
-
We present complexity upper and lower bounds for several well-studied variations of finitely-ambiguous automata (summarised in Table 1). In particular, checking positive resolvability is -complete for finitely-ambiguous automata, -complete for unambiguous (-ambiguous) automata, and in the polynomial hierarchy for (unrestricted) unary automata. Checking -resolvability is -hard even for -ambiguous automata (and -hard over a unary alphabet).
| unambiguous | finitely-ambiguous | general | |||
|
unary | (Thm. 8) | -hard (Thm. 11) (Thm. 4) | ||
| non-unary | -complete (Thms. 9 and 8) | -complete (Thms. 12 and 19) | open | ||
|
unary | (Thm. 10) | -hard (Thm. 11) decidable (Thm. 20) | open | |
| non-unary | -hard (Thm. 9) (Thm. 10) | -hard (Thm. 12) decidable (Thm. 20) | undecidable (Thm. 2) | ||
2 Preliminaries
In this paper, we use , , , , , and to denote the sets of non-negative integers, integers, positive integers, rational numbers, positive rational numbers, and real numbers, respectively. For and two numbers with , the notation (resp., ) denotes the set (resp., ). The half-open intervals and are defined analogously. We also write to denote . The subscript is omitted if it is clear from the context.
Nondeterministic Finite Automata.
A nondeterministic finite automaton (NFA) consists of a finite alphabet , a finite set of states , an initial state , a set of accepting states , and a set of transitions . We also use to signify that . is unary if ; a deterministic finite automaton (DFA) if, for every , there exists at most one state such that ; and complete if, for every , there exists some such that .
Given a word , a run of on is a sequence of transitions , where each transition for , and for . The run is accepting if and . A word is accepted by if there exists an accepting run on it. We denote by the set of words accepted by . Additionally, we use to denote the set of all accepting runs of on . We omit the subscript when it is clear from the context. An NFA is -ambiguous if, for every word , it holds that . It is unambiguous when . Moreover, is finitely-ambiguous if it is -ambiguous for some . We use UFA and FNFA to refer to unambiguous and finitely-ambiguous NFA, respectively.
For , let denote the automaton with as its initial state, and for , let denote the automaton obtained from by restricting its transitions to . For , we often say is nondeterministic in to mean is nondeterministic in . induces a transition function , where is the set of all states where runs on word can end up in when starting from any state . Formally, for all , , and for all and , . When , we often abuse notation and write instead of , and we omit the subscript when it is clear from the context. An NFA is trim if every state is reachable from the initial state, and can reach an accepting state, i.e., and for some words .
Probabilistic Finite Automata.
A probabilistic finite automaton (PFA) is an extension of nondeterministic finite automaton that assigns an acceptance probability to each word. Specifically, is an NFA augmented with an assignment , where for every , . Accordingly, is a 6-tuple of the form . Given a transition , the value represents the probability of transitioning from state to state upon reading the symbol . With a slight abuse of language, we also call a transition of , where . We say that is based on the NFA and call this its underlying NFA.111The condition may not hold for some pairs if the underlying NFA is not complete. Any NFA can be made complete by introducing a non-accepting sink state. Thus, throughout this paper, we assume that the underlying NFA of every PFA is implicitly made complete.
We use to denote the probability that accepts word where:
For every threshold , let denote the set of all words accepted with probability at least , that is:
We also use to refer to the PFA with a given threshold . Similarly, we define , , and . A PFA is called simple if, for every transition of , the probability belongs to . Since transitions with do not affect the language accepted by a PFA, we assume for all transitions in the remainder of this paper.
Stochastic Resolvers.
Given an NFA , a (memoryless) stochastic resolver for resolves nondeterminism during the run on a word on-the-fly, randomly, and positionally. Formally, , such that holds for every pair . A resolver for turns it into a PFA . We call the support of .
Given a threshold , we say that is -memoryless stochastically resolvable (or simply -resolvable) if there exists a resolver for such that , where . An automaton is positively memoryless stochastically resolvable (or simply positively resolvable) if it is -resolvable for some .
3 -Resolvability
In this section we demonstrate the importance of the threshold : we first show that the choice of this threshold defines a spectrum of automata classes in terms of their resolvability. We then turn to the main negative result, that checking -resolvability is undecidable.
Theorem 1.
For every there exists a unary NFA such that is -resolvable but not -resolvable for any .
Proof.
Let where and . The NFA over unary alphabet is as follows. In the initial state upon reading the letter , nondeterministically goes to one of branches, each with states. Consider an arbitrary ordering of all sized subsets of , . For any branch and , the -th state on the -th branch - , is accepting iff . Refer to Figure 3 for an example with . The automaton is -ambiguous, where each word in has exactly accepting runs. Moreover, is -resolvable, since the uniform resolver that picks any transition at with probability , accepts every word with probability exactly . For any other resolver , consider the branches , with the lowest assigned probabilities. Let be the unique index such that . Then for the word , we have . Hence, is not -resolvable for any .
Theorem 2.
The -resolvability problem is undecidable for NFA.
Our approach relies on a reduction from the undecidable universality problem for simple222Note that [19] proves the (strict) emptiness problem for simple PFA is undecidable. Since a PFA is universal if and only if its complement is empty, the universality problem is also undecidable. PFAs [37, 19] to the -resolvability problem for an NFA. Consider a simple PFA over the alphabet , whose underlying NFA is . For a simple PFA, the structure of its underlying NFA uniquely determines the probabilities on its transitions: for each state and letter , there are either one or two outgoing transitions from labelled with ; if there is one transition it must have probability and if there are two, each must have probability .
Intuitively, we want the resolver (if it exists) for the underlying automaton of to always induce a simple PFA. So, is -resolvable if and only if and recognise the same language. In principle, a resolver for an NFA does not necessarily enforce that two outgoing transitions both have probability and may use any arbitrary split. To enforce an equal split, we construct an NFA over an extended alphabet , such that is a super-automaton of . By this, we mean that the alphabet, state set, set of accepting states, and transition set of are all subsets of those of , and we refer to as a sub-automaton of . The constructed NFA is designed so that it admits only one possible -resolver, and that the resolver matches the underlying probabilities of the simple PFA on the part of the automaton of corresponding to . These relations are described in Figure 3.
Our construction has the property that is -resolvable if and only if is universal. Essentially, the only possible resolver induces a probabilistic automaton on such that for all words , where is a fixed word over . This ensures for . The construction itself introduces new words, however these words are -resolvable by construction.
Proof Sketch of Theorem 2.
Without loss of generality, we fix . is not universal if is not, and since universality for NFA is decidable, we assume that . We construct a super-automaton of such that it satisfies the following three properties:
-
C.1
For every state of and every , has at most two distinct transitions of the form for some state .
-
C.2
If is -resolvable, then its -resolvable solution must be a simple PFA.
-
C.3
The language is the disjoint union of two languages, (essentially an extension of ) and (essentially corresponding to the new part of ), satisfying:
-
(a)
For every , .
-
(b)
For every , where for some singleton set over and with , we have .
-
(a)
Properties C.1 and C.2 ensure that the simple PFA based on is the unique -resolvable solution to if it is -resolvable. Notice that regardless of whether has a -resolvable solution, is based on , and for each word , returns its acceptance probability, which may be less than . Property C.3 states that is a -resolvable solution to if and only if is universal. Accordingly, we have:
Lemma 3.
By Lemma 3, we can prove the undecidability of -resolvability by constructing, for any simple PFA with underlying NFA , an NFA satisfying C.1–C.3. In the remainder of this section, we show how to do this and give intuitions for why these properties hold for the constructed automata. Property C.1 will hold trivially by construction, so we will focus on C.2 and C.3.
The automaton will consist of two sub-automata and . The first one, recognises the language , which does not depend on the structure of the original NFA , but rather on the numbers of ’s states and transitions. In contrast, is an extension (super-automaton) of corresponding to the language .
Consider the NFA given in Figure 5, where . This NFA is -resolvable. Moreover, every PFA based on is a -resolvable solution, which is neither unique nor necessarily simple. However, if we add two transitions to and derive the NFA as shown in Figure 5, where for every word , the accepting run on is unique, then the -resolvable solution PFA to becomes both unique and simple. Note that we not only introduce new transitions but also add a newly accepting state to ensure that no additional words over are introduced in a more general case. This example illustrates how property C.2 can be enforced.
More specifically, referring to Figure 7, if has nondeterministic transitions to states and from on reading , we introduce two new transitions, and , in , where and are newly introduced symbols corresponding to the original transitions and , respectively. If we can ensure that there exists a unique word corresponding to state , such that there is a run from the initial state of to with probability exactly , and that the accepting runs on the words and are unique, then we can guarantee that if the PFA is a -resolvable solution to , then the transition probabilities for both and in must be . The details of the run on the word are shown in Figure 8. For words of the form where and , the NFA in this figure has a unique accepting run. Analogous to the NFA , the symbols , , and are newly introduced and are not in . Every PFA based on this automaton is a -resolvable solution if the transitions labelled with , , and have probability exactly . For each state , we define , treating as a symbol. Consequently, the run of from to on has probability exactly . We apply this technique to every nondeterministic transition in . Note that the automaton shown in Figure 8 is a part of , is disjoint from , and connects to through transitions of the form for . Hence, if has a -resolvable solution , then for all transitions inherited from , their probability values in must be . Accordingly, this construction ensures that property C.2 holds.
Apart from the states of that have outgoing nondeterministic transitions, we also introduce a transition to , regardless of whether itself has nondeterministic transitions. See Figure 7 and Figure 8. Consequently, the probability of the run of from to on the word is exactly . Moreover, for every word , we have if and only if . Hence, property C.3b follows.
It is important to explain why we consider the -resolvable problem of instead of the -resolvable one, as in the previous example with the NFA . Refer to Figure 7 for a modified example. Our intention is to force the probability split using words of the form , where and , however the construction introduces other words that need to be managed. For example, the words and belong to for all . However, for the simple PFA based on , we have and for all . Even if we set the probability of the run of from the state to on to be , we still have as . That is, when we introduce the transitions and , we may also introduce additional words into . However, based on our tentative construction of , it is possible that , regardless of whether is universal or not. The words in are of the form , where , with , and is a symbol introduced for a nondeterministic transition, such as or , etc.
To address this issue, we ensure the probability is at least probability when , we construct a DFA recognising the language and add it to . The automaton includes a unique transition from the initial state to a state upon reading symbol . This transition is the same as the one shown in Figure 8, with the rest of continuing from . For every simple PFA based on the automaton given in Figure 8, the probability value of the transition is . Thus, for every additional word , we have , ensuring that property C.3a holds. Hence, the constructed satisfies properties C.1–C.3.
From Lemma 3, it follows that the -resolvability problem for NFA is undecidable.
4 Deciding Resolvability for Unary Finite Automata
Theorem 4.
Positive resolvability is in for unary NFA.
For a unary NFA a memoryless stochastic resolver induces a unary probabilistic automaton, or equivalently a Markov chain. This is given by an initial distribution as a row vector , a stochastic matrix and a final distribution as a column vector such that . We make use of the following lemma, which summarises standard results in Markov chain theory to our needs (see e.g. [30, Sec 1.2-1.5] or [34, Sec 1.8]). The lemma shows that there are a sequence of limit distributions that are visited periodically. Essentially, we get, for each word length , a set of reachable states, and except for a possible initial sequence, these sets of states repeat periodically. Once in the periodical part, whenever there is a reachable accepting state, there must be some reachable accepting state in a bottom strongly connected component (SCC) to ensure the probability is bounded away from zero. The key point of the following lemma is to translate this into the support of the limit distributions for these states to be non-zero / zero for reachable states in- / outside of bottom SCCs, so that we only need to consider the support graph of the Markov chain, not the probabilities themselves. This allows us to guess the support of the resolver in and verify in that any resolver with this support would suffice.
Lemma 5.
Let be a -dimensional Markov chain with initial distribution . There exists , bounded by an exponential in , and limit distributions , such that . Furthermore, is non-zero if and only if
-
1.
is in a bottom SCC, and
-
2.
is reachable in from some state in by some path of length for some .
We now show how to decide whether there is a stochastic memoryless resolver.
Proof of Theorem 4.
Let be a unary NFA over the alphabet , with , initial state encoded in a row vector and final states encoded in a column vector . We ask if there is a with support at most and such that whenever .
If exists, it has some support and we guess this support of non-deterministically. The choice of support induces a new NFA , in which every edge will be attributed a non-zero probability and . We verify, in [43], that . If not, this is not a good support.
Henceforth, we assume and consider the condition to check whether the support is good. For any with support we have for . It remains to decide whether this probability can be bounded away from zero, that is for some , whenever . The condition we describe is independent of the exact choice of and is based only on the structure of . Using from Lemma 5 we decompose into phases and define for all the set . Each is either finite, in which case it turns out there is nothing to do, or eventually periodic with period , in which case we use Lemma 5’s characterisation of non-zero limit:
- is finite.
-
There is nothing to decide: any with support induces a lower bound on the weight of the words in , as the minimum over a finite set of non-zero values.
- is eventually periodic.
-
We check there exists a path from to some final state of length for some , and that is in some bottom SCC in . Then for any with support , Lemma 5 entails a limit distribution such that , in which is non-zero. Thus . In particular, there exists such that, for all , we have . Hence, there is a lower bound on the weights of words in : , which is a minimum over a finite set of non-zero values.
If there is no such path, then for any with support , the limit distribution is zero in all final states: the probability tends to zero no matter the exact choice of probabilities.
For a given , it can be decided in polynomial time whether is finite and whether there is a path of the given type. On a boolean matrix representing the reachability graph of , the vector and boolean matrix can be computed by iterated squaring in which the reachability questions can be checked.
Thus to summarise, our procedure guesses a support and the period in , and verifies in both that and guess the to verify the required reachability queries for . In Theorem 11 we show that the problem is -hard already in the finite-ambiguous case, we present this result alongside the non-unary case in Section 6 due to commonalities.
5 Unambiguous Finite Automata
Given an NFA , a support is bad if there is no resolver over that positively resolves , that is, is not a positively resolvable solution to for each over . We start this section with a property related to bad supports for finitely-ambiguous automata, which we use to derive the decidability and complexity bounds for the resolvability problems.
Lemma 6.
Let be a support for an FNFA with . For a word with accepting runs, , let be the minimum number of nondeterministic transitions present in any of the . Then is a bad support if and only if there is an infinite sequence of words such that is a strictly increasing sequence.
For a UFA– where each word has exactly one accepting run – removing a transition without changing the language implies that the transition either originates from an unreachable state or leads to a state with empty language. Such transitions can thus be safely removed or assigned probability zero. Assuming the UFA is trim, its support is unique. It is not positively resolvable if and only if this support is bad.
It is easy to see that a UFA is not positively resolvable if it admits an accepting run of the form , where is the initial state, is an accepting state, and there is a nondeterministic transition taken while reading the infix . By pumping , we obtain a sequence of accepted words of the form , each with a unique accepting run, but with decreasing probabilities assigned by any stochastic resolver. This follows from the fact that the loop induced by contains a nondeterministic transition, which causes the probability mass to diminish. The UFA in Figure 1(b) illustrates this phenomenon: it is unambiguous but not positively resolvable. This is witnessed by the word , where the first corresponds to the nondeterministic, pumpable part of the word.
In the following, we show that the existence of such a witness word is both a necessary and sufficient condition for a UFA not to be positively resolvable.
Lemma 7.
A UFA is not positively resolvable if and only if there exists a word such that the accepting run on satisfies the following conditions:
-
1.
After reading the prefix , the run reaches a state , and after subsequently reading , it returns to the same state, i.e., . Moreover, reading from leads to an accepting state: .
-
2.
The words and begin with the same letter , it follows that the transition taken when reading from is nondeterministic.
By guessing this witnessing word of Lemma 7 letter by letter, we have an NL procedure for deciding whether a UFA is positively resolvable or not.
Theorem 8.
The positive resolvability problem for UFA is in NL.
We can show a matching lower bound in the unambiguous case by a straightforward reduction from the emptiness problem for UFA, which is known to be NL-complete.
Theorem 9.
Given a UFA, it is NL-hard to decide if it is positively resolvable, and NL-hard to decide if it is -resolvable for any fixed .
For a positively resolvable UFA , Lemma 7 essentially states that no accepting run may contain nondeterministic transitions in its looping part. This is equivalent to requiring that all transitions within SCCs of are deterministic. Exploiting this structural property, we can compute the largest possible value of such that is -resolvable. To do so, we collapse all SCCs into single nodes, yielding a rooted directed acyclic graph (DAG), and reduce the problem to counting the maximum number of disjoint paths in this DAG, which can be computed in polynomial time.
Theorem 10.
It is polynomial time to decide whether a UFA is -resolvable.
6 Finitely-Ambiguous Finite Automata
In this section we establish decidability and hardness for both positive resolvability and -resolvability for finitely-ambiguous NFA.
6.1 Hardness of Resolvability
We show that when an NFA is finitely-ambiguous, deciding the existence of a resolver, and the existence of a -resolver are both -hard in the unary case and -hard otherwise. While the unary and non-unary cases differ slightly, both are based on deciding whether the union of given DFAs are universal.
The ideas of both proofs are the same, we will extend the given automaton with a new component that ensures it is universal, but the new component itself will not be positively resolvable (see Figure 9). Therefore, if the existing -DFAs are universal then the resolver that uniformly resolves between these -DFAs (assigning zero weight to the new component) is sufficient. However, if the -DFAs are not themselves universal, then the new component must be used to recognise some words, but this component is not positively resolvable, and so neither is the whole automaton. The difference between the proofs will be how we ensure this works even if only a single short word is not in the union of the -DFAs.
In the unary case we reduce from the problem of whether a unary NFA is universal which is -hard [43], but similarly to [13, Theorem 7.20], we can assume that the shape is the union of simple cycles. By bringing into Chrobak normal form in polynomial time the automaton has an initial stem and a nondeterministic transition to cycles at the end of the stem. But since universality requires that all words are accepting, each state of the stem must be accepting, which can be pre-checked in polynomial time. Thus the hard case remains to determine whether the union of the remaining -cycle DFAs are universal.
Theorem 11.
Given a unary k-ambiguous NFA it is -hard to decide if it is positively resolvable, and -hard to decide if it is -resolvable for .
In the non-unary case we show -hardness via the problem asking whether the union language of -DFAs is universal, which is -complete. This problem can be seen as the complement of the (well-known) problem of intersection emptiness for DFAs, that is, whether the intersection of (not fixed) DFAs is empty, which is known to be -complete [26]. The unary case exploits the cyclic structure to ensure that if some word is not in the union, then there are indeed infinitely many missing words. There is no such natural analogue in the non-unary case requiring a modified construction.
Theorem 12.
Given a -ambiguous NFA, it is -hard to decide if it is positively resolvable, and -hard to decide if it is -resolvable for .
6.2 Deciding Positive Resolvability for Finitely-Ambiguous NFA
In Section 5, we established positive resolvability for unambiguous automata by identifying a witnessing “bad” word. In this section, we generalise the notion of a “bad” word to finitely-ambiguous NFA. For any UFA , there exists a unique support such that assuming is trim. However, when is no longer unambiguous, there may be multiple such supports satisfying . If is not positively resolvable, then all of its supports are bad, in the sense that no stochastic resolver over any of these supports can positively resolve . Our algorithm for deciding positive resolvability works by checking if supports of are bad. We characterise a bad support , using a witness bad word that satisfies several conditions. This is a generalisation of the witnessing word in the UFA case. Intuitively, a bad word for a support is a word, which contain subwords, that can be pumped arbitrarily to produce new words with acceptance probability arbitrarily close to . These “pumpable” subwords must preserve some reachability behaviour as well as contain probabilistic choices with probability in .
Definition 13 (Bad word).
Let be an FNFA and be a support. Then a word with accepting runs is a bad word for if for some , there exists a decomposition with words , , sets of states , , and states with for each such that:
-
1.
For each , all accepting runs of in from end in after reading , i.e., and .
-
2.
An accepting run of in must be in some for some after reading .
-
3.
For each and each , every accepting run of that reaches after reading the prefix also returns to after subsequently reading . Moreover, when , this run of from to contains at least one transition from which is nondeterministic in .
-
4.
For each , contains all states that are reached from after reading , but has no continuation to an accepting run in for the remaining suffix , i,e., and . Moreover, is also exactly the set of states that are reached from after reading , with no continuation to an accepting run in for the remaining suffix , i.e., and .
Example 14.
The NFA in Figure 10(a) is 4-ambiguous. Consider the full support containing all transitions of . The word serves as a bad word witness for , with decomposition where , , , , , and . There are four distinct accepting runs on ; see Figure 10(b) for an illustration. Based on Definition 13, for , we have , and . Among the four accepting runs, two take nondeterministic transitions from when reading , and the other two do so when reading . Runs from to are highlighted and nondeterministic transitions are coloured in the figure. This shows that is a bad word for : the entire sequence of words admits four accepting runs each, and the probability assigned to each such word diminishes as increases under any stochastic resolver over . In fact, this automaton is not positively resolvable. Although there exists another support which still preserves the language of – the one that excludes the transitions going through , we can show that this support is also bad, witnessed by the same bad word. With this support, we no longer have the second accepting run in Figure 10(b).
Detecting bad words involves finding a decomposition as well as suitable ’s, ’s and ’s. In order to explicitly track these objects for some word, we consider an automata , called the run automaton of . Intuitively, a run of a word on , records all the states reached in accepting runs of as well as the reachable states from which there are no continuation to accepting runs.
Run automata.
Let be -ambiguous. Then the run automaton has state space , and transitions iff in and . Also, for every state in , the set of states in the tuple and the set are disjoint. Every word with accepting runs has a run on from initial state to where and such that 1) in the th step of the run, it reaches if the th accepting run of is in after reading and 2) iff there is no accepting run of from the reachable state . We call such a run, a nice run of in . For a word in with strictly fewer than accepting runs will have such a run on , where for some , = for all , i.e. there will be at least two copies of same run. Every word has a unique nice run on up to duplication and shuffling of accepting runs. A bad word for is essentially a word in which has a nice run on such that in this nice run, the component of the run on the subword is a self-loop in with several accepting runs containing a nondeterministic transition from . In Example 14 these self loops happen at states and in the nice run of the bad word in the run automata.
The following lemma ensures that for the loop words in Definition 13, there is always a unique loop from any state back to itself. Assume there are two loops from to over the word . Let be a word that there is a run from to and a word that there is run from to a final state. Then, the sequence of words admits an unbounded number of accepting runs, contradicting that the automaton is finitely-ambiguous.
Lemma 15.
In an FNFA, for any accepting run containing a loop from to over the word , it is the unique loop from to over .
A nice run for a bad word contains a cycle corresponding to each subword . The following lemma ensures that we can construct new words by pumping these subwords while preserving the number of accepting runs.
Lemma 16.
Let be a word in with accepting runs, whose nice run in has a cycle on the subword . Then for each , also has accepting runs.
Corollary 17.
Let be a bad word for support with accepting runs. Then for each , also has accepting runs.
For FNFA, a support is bad when either or there is a bad word to witness that the support is bad. The following is a key lemma of this section, demonstrating that the existence of such a word is necessary and sufficient for a support to be bad.
Lemma 18 (Bad support-bad word).
Let be an FNFA, and let be a support. Then, is a bad support if and only if or there exists a bad word for .
Proof Sketch.
One direction is straightforward: If there exists a bad word as defined in Definition 13, we construct a sequence of words by simultaneously pumping all the loop words. By Corollary 17, each word in this sequence has the same number of accepting runs. However, the number of nondeterministic transitions in the accepting runs of each word increases. By Lemma 6, this implies that the support is bad.
Towards the other direction, suppose we are given a bad support. Then, by Lemma 6, there exists a sequence of words whose accepting runs contain an increasing number of nondeterministic transitions. We select a word from this sequence such that every accepting run of contains more nondeterministic transitions than the number of states in the run automaton. This ensures that, in any nice run over in the run automaton, each accepting run must traverse a self-loop that includes a nondeterministic transition. Formally, for the th accepting run, the word can be decomposed as , where a nice run reaches the state after reading , and returns to after reading the loop word . Moreover, the subrun over contains at least one nondeterministic transition. Since the loop segments may overlap across different accepting runs, we construct a new word by pumping these loop segments to ensure they are disjoint. The resulting word satisfies all the conditions of Definition 13, and is therefore a bad word.
To decide the positive resolvability of an FNFA , we consider all possible supports such that , and check whether each support is bad by analysing the run automaton . According to Lemma 18, if a support is bad, there must exist a bad word for it, and there must also be a corresponding nice run over this word in . This nice run encodes the structure of all accepting runs of on the bad word. In particular, for each accepting run of , the nice run in includes a loop that contains at least one nondeterministic transition from in its component corresponding to . To show that a support is bad, it suffices to search for such nice runs in , which gives us a decidable procedure. A naive algorithm to check for a bad word would be to nondeterministically guess a nice run of a bad word in from to with and . This involves guessing a letter at each step, keeping track of states reached in each run, i.e. at th step computing the states and guessing for state in . For the bad word decomposition, we would also need to guess the states and the state for simulating the cycle in with nondeterministic transition in some run. We also track runs that have already seen nondeterministic transition in some cycle on . Finally, we have a bad word, if all runs have seen nondeterministic transitions in some cycle and the sets ’s are consistent with the final guessed word.
However, given an FNFA, since its degree of ambiguity is known to be bounded by [46], the size of the run automaton can be in the worst case, which is doubly exponential in the size of . Hence the described procedure is not in . By slightly modifying this procedure, instead of storing the state tuple reached at every step, we store the set of states along with keeping track of those states in , to which all accepting runs are yet to see nondeterministic transitions in some cycle in . Additionally, for the cycle part, when we guess , since from Lemma 15 we know that every state has unique run to itself for the subword , there are at most runs to track in this part. So we arbitrarily order the runs and track the progression of these runs in the cycle. Note that, in this part any transition doesn’t change the size of the sets and hence are bijections on . We guess these bijections until the compositions of all the bijections is the identity map, i.e. each run has returned to the point of entering the cycle. At the end of the cycle we remove all states from , whose cycles have encountered nondeterministic transitions from . Since this procedure stores information only about sets of size at most , as well as bijections on , the state space can be described using , giving us a procedure for detecting bad words.
Theorem 19.
It can be decided in if an FNFA is positively resolvable. Moreover, the shortest bad word is of length at most .
Proof.
We provide a algorithm for the complement problem, i.e. checking if the given FNFA is not positively resolvable. The first step is to go through all possible supports that are language equivalent to . This can be checked in [43] for general NFA.
Given a support with , we check whether it is bad by nondeterministically guessing a bad word . Specifically, we guess a word of the form , satisfying the conditions of Definition 13, letter by letter. During this process, we also guess the start and end points of each , and simultaneously track an abstraction of the accepting runs, as well as of all non-accepting runs.
While reading a part , which we call branching, or , which we call looping, the abstraction intuitively preserves the following for a bad word: (1) which states are reachable on the overall word read so far, but only appear on rejecting runs in a set , (2) which states are part of an accepting run of the overall word in a set , and (3) which states are part of the accepting runs but have not yet been shown to be “bad”, in a set ; formally, these are the states reached by an accepting run whose certificate state is (2nd item in Definition 13) with . The formal rules for these sets are: and .
The update rules from sets to when guessing a letter are that all -successors of a state in must be in , all -successors of a state in must be in and at least one of them must be in , and all states in must be -successors of states in .
When entering a looping part , we remember the set and denote as . On reading the abstraction additionally tracks (4) the set of states that occurs on some accepting run at the beginning of and remember as ( is the from Lemma 18), (5) which state is on the path for the runs with index (that start and end with in terms of Lemma 18), (6) whether this path through has seen a non-deterministic transition using a boolean flag, and (7) a bijection .
The update rules when guessing a letter in the looping part additionally require that, for all states resp. , exactly one -successor is in resp. ; is left unchanged, and the boolean flag is set to true if the -transition from is non-deterministic; otherwise it is left unchanged. The bijection is updated to such that, if , then such that and is an -successor of .
Moving from the branching mode to looping mode can be done through an -transition, setting to , to the identity and to , guessing and setting the boolean flag to false. Moving back to branching mode happens through an -transition that can be taken when the boolean flag is set to true, is the identity, is and is . is removed from in this -transition.
Finally, we accept the run when we reach a state with and in the branching mode.
The algorithm essentially reduces to a reachability problem on a graph with an exponential number of nodes. However, rather than explicitly constructing this graph, we operate on abstractions involving only a constant number of sets, variables, and functions, thereby requiring only polynomial space. The algorithm is then in NPSPACE, hence, in , since NPSPACE=[39].
To show the correctness of the algorithm, we prove that a bad word exists if and only if we can construct an accepting run in the graph. For a bad word for some with accepting runs, we observe that the accepting runs do not have a natural order among them, and that a repetition of each may diminish the probability mass of several accepting runs. We give each accepting run an index that refers to the first that diminishes it. In particular, the accepting runs with index are in after reading . We simply take the terms from Definition 13 and construct an accepting run in the graph.
We can likewise construct a bad word from an accepting run on the graph as follows: starting with , the words between two -transitions define words ; for the we also store their respective and as and , respectively. It is now easy to see that this satisfies all local conditions of Definition 13, so that all we need to show is that all accepting runs are in after reading for some . But this is guaranteed by .
We get as a side result, the shortest bad word cannot be longer than the size of the graph described, and thus, . This is a rough bound: each state can appear in both the domain and range of the bijection, leading to at most possibilities. There are further possibilities: if a state is in the range of the bijection, then it belongs to , and consequently, it can also be in ; if it is not in the range of the bijection, then it does not belong to and can either be in (since and are disjoint) or not. In addition, it can be the state that we need to track in step 5. It may be in the set or not.
6.3 Deciding -Resolvability for Finitely-Ambiguous NFA
Here we will provide an algorithm to decide -resolvability for FNFA. We do this by building a finite system of inequalities and check if it is satisfiable. Decidability follows from the decidability of first-order theory of reals [44]. Towards this, we consider primitive words: a word is primitive for if a nice run of in has no cycles.
Theorem 20.
It is decidable whether an FNFA is -resolvable.
Proof Sketch.
The key idea is that for each primitive word and corresponding nice run in the run automaton, we can obtain a number , which is a lower bound on the probability of any word whose nice run is the same as without the self loops. Moreover, we can find a sequence of such words whose limit probability is . Hence, the automaton is -resolvable if and only if there is a support that satisfies for every primitive word .
To encode this idea in a formula in the theory of the reals, we have a variable for each , to express the probabilities assigned by some stochastic resolver over a given support . Let denote the set of constraints ensuring that the variables satisfy the probabilistic constraints and take values strictly within .
The set of all primitive words associated with the support can be obtained from the run automaton , along with the corresponding symbolic probability . We define the formula for the support as This gives our final system of inequalities .
We conclude by noting that our analysis does not extend to NFA that are not finitely-ambiguous, as Lemma 6 fails for bad supports in this setting.
7 Discussion
We have introduced the notion of -resolvability as a new measure for the degree of nondeterminism. We showed that checking this property is undecidable for NFA, and provided further decidability and complexity results for important special cases, in particular finitely-ambiguous automata.
This opens new fields of study, especially whether there are more meaningful classes of NFA where positive or -resolvability are decidable. More immediate future work includes closing the remaining complexity gaps and discovering whether or not checking positive resolvability for general NFA is decidable.
Other challenges that arise are how these results extend to more expressive languages, such as (visible) counter or pushdown languages, and how they extend to -regular languages. For the latter challenge, several of our results transfer elegantly. The undecidability of -resolvability holds even for weak -automata. For finitely-ambiguous case, we can just adjust our definition of bad words to bad prefixes: where the accepting and rejecting runs in a bad word end in final and non-final states for bad words, for bad prefixes there needs to be some infinite word that is accepted from all states the prefixes of accepting runs end in but from none of the states the prefixes of non-accepting runs end in. Checking if such a word exists can be done in for nondeterministic parity automata (NPA). It follows that the positive resolvability problem for finitely-ambiguous NPA is -complete. The -resolvability problem is also decidable for finitely-ambiguous NPA. We give details in Appendix A.
References
- [1] Bader Abu Radi and Orna Kupferman. Minimizing gfg transition-based automata. In International Colloquium on Automata, Languages and Programming (ICALP), 2019. doi:10.4230/LIPIcs.ICALP.2019.100.
- [2] Rajab Aghamov, Christel Baier, Toghrul Karimov, Joris Nieuwveld, Joël Ouaknine, Jakob Piribauer, and Mihir Vahanwala. Model checking markov chains as distribution transformers. In Principles of Verification: Cycling the Probabilistic Landscape - Essays Dedicated to Joost-Pieter Katoen on the Occasion of His 60th Birthday, Part II, volume 15261 of Lecture Notes in Computer Science, pages 293–313. Springer, 2024. doi:10.1007/978-3-031-75775-4_13.
- [3] Marc Bagnol and Denis Kuperberg. Büchi Good-for-Games Automata Are Efficiently Recognizable. In IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 16:1–16:14, 2018. doi:10.4230/LIPIcs.FSTTCS.2018.16.
- [4] Christel Baier, Luca de Alfaro, Vojtěch Forejt, and Marta Kwiatkowska. Model Checking Probabilistic Systems, pages 963–999. Springer International Publishing, 2018. doi:10.1007/978-3-319-10575-8_28.
- [5] Christel Baier, Florian Funke, Simon Jantsch, Toghrul Karimov, Engel Lefaucheux, Joël Ouaknine, David Purser, Markus A. Whiteland, and James Worrell. Parameter synthesis for parametric probabilistic dynamical systems and prefix-independent specifications. In 33rd International Conference on Concurrency Theory, CONCUR 2022, September 12-16, 2022, Warsaw, Poland, volume 243 of LIPIcs, pages 10:1–10:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPICS.CONCUR.2022.10.
- [6] Christel Baier, Holger Hermanns, and Joost-Pieter Katoen. The 10,000 Facets of MDP Model Checking, pages 420–451. Springer-Verlag, 2022. doi:10.1007/978-3-319-91908-9_21.
- [7] Christel Baier, Stefan Kiefer, Joachim Klein, David Müller, and James Worrell. Markov chains and unambiguous automata. J. Comput. Syst. Sci., 136:113–134, 2023. doi:10.1016/J.JCSS.2023.03.005.
- [8] Udi Boker and Karoliina Lehtinen. Good for games automata: From nondeterminism to alternation. In International Conference on Concurrency Theory (CONCUR), volume 140, pages 19:1–19:16, 2019. doi:10.4230/LIPIcs.CONCUR.2019.19.
- [9] Udi Boker and Karoliina Lehtinen. History Determinism vs. Good for Gameness in Quantitative Automata. In IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 38:1–38:20, 2021. doi:10.4230/LIPIcs.FSTTCS.2021.38.
- [10] Udi Boker and Karoliina Lehtinen. Token games and history-deterministic quantitative automata. In IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 120–139. Springer International Publishing, 2022. doi:10.1007/978-3-030-99253-8_7.
- [11] Sougata Bose, Thomas A. Henzinger, Karoliina Lehtinen, Sven Schewe, and Patrick Totzke. History-deterministic timed automata are not determinizable. In International Workshop on Reachability Problems (RP), 2022. doi:10.1007/978-3-031-19135-0_5.
- [12] Sougata Bose, Thomas A. Henzinger, Karoliina Lehtinen, Sven Schewe, and Patrick Totzke. History-deterministic timed automata. Log Meth Comput Sci, Volume 20, Issue 4, October 2024. doi:10.46298/lmcs-20(4:1)2024.
- [13] Dmitry Chistikov, Stefan Kiefer, Andrzej S. Murawski, and David Purser. The Big-O Problem. Log Meth Comput Sci, 18(1), 2022. doi:10.46298/LMCS-18(1:40)2022.
- [14] Thomas Colcombet. The theory of stabilisation monoids and regular cost functions. In International Colloquium on Automata, Languages and Programming (ICALP), pages 139–150, 2009. doi:10.1007/978-3-642-02930-1_12.
- [15] Wojciech Czerwinski, Engel Lefaucheux, Filip Mazowiecki, David Purser, and Markus A. Whiteland. The boundedness and zero isolation problems for weighted automata over nonnegative rationals. In LICS ’22: 37th Annual ACM/IEEE Symposium on Logic in Computer Science, Haifa, Israel, August 2 - 5, 2022, pages 15:1–15:13. ACM, 2022. doi:10.1145/3531130.3533336.
- [16] Laure Daviaud, Marcin Jurdziński, Ranko Lazić, Filip Mazowiecki, Guillermo A. Pérez, and James Worrell. When are emptiness and containment decidable for probabilistic automata? J. Comput. Syst. Sci., 119:78–96, 2021. doi:10.1016/j.jcss.2021.01.006.
- [17] Nathanaël Fijalkow, Hugo Gimbert, Edon Kelmendi, and Youssouf Oualhadj. Deciding the value 1 problem for probabilistic leaktight automata. Log. Methods Comput. Sci., 11(2), 2015. doi:10.2168/LMCS-11(2:12)2015.
- [18] Nathanaël Fijalkow, Cristian Riveros, and James Worrell. Probabilistic automata of bounded ambiguity. Information and Computation, 282:104648, 2022. Special issue on 9th International Workshop Weighted Automata: Theory and Applications (WATA 2018). doi:10.1016/j.ic.2020.104648.
- [19] Hugo Gimbert and Youssouf Oualhadj. Probabilistic automata on finite words: Decidable and undecidable problems. In Automata, Languages and Programming, pages 527–538, 2010. doi:10.1007/978-3-642-14162-1_44.
- [20] Shibashis Guha, Ismaël Jecker, Karoliina Lehtinen, and Martin Zimmermann. A Bit of Nondeterminism Makes Pushdown Automata Expressive and Succinct. In International Symposium on Mathematical Foundations of Computer Science (MFCS), pages 53:1–53:20, 2021. doi:10.4230/LIPIcs.MFCS.2021.53.
- [21] Ernst Moritz Hahn, Guangyuan Li, Sven Schewe, Andrea Turrini, and Lijun Zhang. Lazy probabilistic model checking without determinisation. In International Conference on Concurrency Theory (CONCUR), pages 354–367, 2015. doi:10.4230/LIPIcs.CONCUR.2015.354.
- [22] Ernst Moritz Hahn, Mateo Perez, Sven Schewe, Fabio Somenzi, Ashutosh Trivedi, and Dominik Wojtczak. Good-for-mdps automata for probabilistic analysis and reinforcement learning. In Tools and Algorithms for the Construction and Analysis of Systems (TACAS), volume 12078, pages 306–323. Springer, 2020. doi:10.1007/978-3-030-45190-5_17.
- [23] Thomas A. Henzinger, Karoliina Lehtinen, and Patrick Totzke. History-deterministic timed automata. In International Conference on Concurrency Theory (CONCUR), 2022. doi:10.4230/LIPIcs.CONCUR.2022.14.
- [24] Thomas A. Henzinger and Nir Piterman. Solving games without determinization. In Computer Science Logic (CSL), pages 395–410. Springer Berlin Heidelberg, 2006. doi:10.1007/11874683_26.
- [25] Thomas A. Henzinger, Aditya Prakash, and K. S. Thejaswini. Resolving nondeterminism with randomness, 2025.
- [26] Dexter Kozen. Lower bounds for natural proof systems. In 18th Annual Symposium on Foundations of Computer Science (sfcs 1977), pages 254–266, 1977. doi:10.1109/SFCS.1977.16.
- [27] Denis Kuperberg and Michał Skrzypczak. On determinisation of good-for-games automata. In International Colloquium on Automata, Languages and Programming (ICALP), pages 299–310, 2015. doi:10.1007/978-3-662-47666-6_24.
- [28] Orna Kupferman, Shmuel Safra, and Moshe Y Vardi. Relating word and tree automata. Ann. Pure Appl. Logic, 138(1-3):126–146, 2006. doi:10.1016/J.APAL.2005.06.009.
- [29] Orna Kupferman and Moshe Y. Vardi. Weak alternating automata are not that weak. ACM Trans. Comput. Log., 2(3):408–429, 2001. doi:10.1145/377978.377993.
- [30] Gregory F. Lawler. Introduction to Stochastic Processes. Chapman and Hall/CRC, 2nd edition, 2010.
- [31] Karoliina Lehtinen and Aditya Prakash. The 2-token theorem: Recognising history-deterministic parity automata efficiently, 2025.
- [32] Karoliina Lehtinen and Martin Zimmermann. Good-for-games -pushdown automata. Log Meth Comput Sci, 18, 2022. doi:10.1145/3373718.3394737.
- [33] Yong Li, Soumyajit Paul, Sven Schewe, and Qiyi Tang. Accelerating markov chain model checking: Good-for-games meets unambiguous automata. In Computer Aided Verification (CAV), 2025.
- [34] J.R. Norris. Markov Chains. Cambridge University Press, 1998.
- [35] Alexander Okhotin. Unambiguous finite automata over a unary alphabet. Information and Computation, 212:15–36, 2012. doi:10.1016/j.ic.2012.01.003.
- [36] Joël Ouaknine and James Worrell. Positivity problems for low-order linear recurrence sequences. In Proceedings of the Twenty-Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2014, Portland, Oregon, USA, January 5-7, 2014, pages 366–379. SIAM, 2014. doi:10.1137/1.9781611973402.27.
- [37] Azaria Paz. Introduction to Probabilistic Automata. Academic Press, 2014.
- [38] Alexander Rabinovich and Doron Tiferet. Degrees of ambiguity for parity tree automata. In Christel Baier and Jean Goubault-Larrecq, editors, 29th EACSL Annual Conference on Computer Science Logic, CSL 2021, January 25-28, 2021, Ljubljana, Slovenia (Virtual Conference), volume 183 of LIPIcs, pages 36:1–36:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPICS.CSL.2021.36.
- [39] Walter J. Savitch. Relationships between nondeterministic and deterministic tape complexities. Journal of Computer and System Sciences, 4(2):177–192, 1970. doi:10.1016/S0022-0000(70)80006-X.
- [40] Sven Schewe. Büchi complementation made tight. In Susanne Albers and Jean-Yves Marion, editors, 26th International Symposium on Theoretical Aspects of Computer Science, STACS 2009, February 26-28, 2009, Freiburg, Germany, Proceedings, volume 3 of LIPIcs, pages 661–672. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Germany, 2009. doi:10.4230/LIPICS.STACS.2009.1854.
- [41] Sven Schewe. Minimising good-for-games automata is NP-complete. In IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS), 2020. doi:10.4230/LIPIcs.FSTTCS.2020.56.
- [42] Erik Meineche Schmidt. Succinctness of description of context-free, regular and unambiguous languages. Cornell University, 1978. doi:10.5555/908560.
- [43] L. J. Stockmeyer and A. R. Meyer. Word problems requiring exponential time (preliminary report). In Symposium on Theory of Computing (STOC), pages 1–9. Association for Computing Machinery, 1973.
- [44] Alfred Tarski and J. C. C. McKinsey. A Decision Method for Elementary Algebra and Geometry. University of California Press, dgo - digital original, 1 edition, 1951. doi:10.2307/jj.8501420.
- [45] Mihir Vahanwala. Skolem and positivity completeness of ergodic markov chains. Inf. Process. Lett., 186:106481, 2024. doi:10.1016/J.IPL.2024.106481.
- [46] Andreas Weber and Helmut Seidl. On the degree of ambiguity of finite automata. Theor Comput Sci, 88(2):325–349, 1991. doi:10.1016/0304-3975(91)90381-B.
Appendix A Application to Automata over Infinite Words
A nondeterministic parity automaton (NPA) is a finite alphabet , a finite set of states , an initial state , a set of transitions , a priority function for some . An NPA accepts a set of infinite words in . A run of on an infinite word is an infinite sequence of transitions , where each for . A run naturally generates an infinite trace over , where the -th element in this sequence is . Let be the numbers that occur infinitely often in . The run is accepting if and the maximum element in is even. A Büchi automaton is an NPA where takes values in . A Büchi automaton can be described by providing the set of states with priority as the accepting set of states. A Büchi automata is weak iff every SCC contains either only accepting states or only rejecting states. Let denote the set of all accepting runs of on . The notions of -ambiguous and finitely-ambiguous naturally extends to NPA based on the cardinality of .
A word induces a probability measure over the measurable subsets of , defined via the -algebra generated by basic cylinder sets in the standard way. The acceptance probability of in is then given by:
Definitions of positive resolvability and -resolvability extends naturally to NPA.
A.1 Undecidability of -Resolvability
We have shown that the -resolvability problem for automata over finite words (i.e., NFA) is undecidable. In this subsection, we extend this result to automata over infinite words.
Given an NFA , define the Büchi automaton as follows:
-
, where .
-
, where .
-
.
-
.
By construction, has a unique accepting state , which is also a sink state, making a weak automaton. Suppose is a PFA based on . We construct the corresponding probabilistic automaton based on by adding transitions of the form to for all . This construction ensures that for every word . Consequently, for every , is -resolvable if and only if is -resolvable. Together with the undecidability of the -resolvability problem for NFA (Theorem 2), we obtain the following:
Theorem 21.
The -resolvability problem for weak nondeterministic Büchi automata is undecidable.
A.2 Decidability for Finitely-ambiguous NPA
Our algorithm for FNFA also extends to finitely-ambiguous NPA using similar analysis. Since the number of accepting runs of every word is bounded by some , Lemma 6 holds for finitely-ambiguous NPA as well.
Lemma 22.
Let be a support for a finitely-ambiguous NPA with . Then is a bad support if and only if for every , there is at least one word such that has at least nondeterministic transitions from in each of its accepting runs.
Hence it is enough to track the behaviour of the NPA up to a finite prefix. Towards this goal, the notion of bad words can be adapted to NPA using bad prefixes. Let denote the -automaton with as its initial state.
Definition 23 (Bad prefix).
Let be a finitely-ambiguous NPA and be a support. Then a word is a bad prefix for if for some , there exists a decomposition with words , , sets of states , states with for each and an -word such that and
-
1.
For each , all accepting runs of from end in after reading , i.e., and .
-
2.
An accepting run of must be in some for some after reading .
-
3.
For each and each , every accepting run of that reaches after reading the prefix also returns to after subsequently reading . Moreover, when , this run of from to contains at least one transition from which is nondeterministic in .
-
4.
For each , contains all states that are reached from after reading , but has no continuation to an accepting run for the remaining suffix , i,e., and . Moreover, is also exactly the set of states that are reached from after reading , with no continuation to an accepting run for the remaining suffix , i.e., and .
Lemma 24 (Bad support-bad prefix).
Let be a finitely-ambiguous NPA and be a support of . Then is a bad support for iff or there exists a bad prefix for .
Hence, our algorithm for deciding the positive resolvability of FNFA can be extended to finitely-ambiguous NPA by adding an accepting mode. This mode verifies whether there exists an -word in the set . In the branching mode, a transition to the accepting mode is always possible when . Once the system enters the accepting mode, it remains there.
To check whether or not is empty, we check if holds. To do this, we can simply translate the individual for all to NBAs and construct an NBA recognising ; the blow-up for this is small.
We can now check whether or not holds.
For this, we complement using [40] to the complement NBA , but note that this complement – including the states and transitions – can be represented symbolically by itself – it only uses subsets of the states in (the reachable states and a subset thereof used for a breakpoint construction) and level rankings, which are functions from the reachable states of to natural numbers up to , where is the number of states of [29, 40].
We can now check whether or not holds.
To do this, we can search in the exponentially larger, but polynomially represented, product space of (the product automaton of for all and ) to check if we can reach a product state, which can loop to itself while seeing an accepting state of each of the automata. This can be checked in in the explicit size of the product automaton and thus in in its representation.
Theorem 25.
The positive resolvability problem for finitely-ambiguous NPA is -complete.
Let the degree of ambiguity of a finitely-ambiguous NPA be , which can be decided [38, Proposition 21]. Note that in [38], the notion of finite ambiguity differs from ours: an automaton is called finitely ambiguous if is finite for every word in the language. What we refer to as finitely-ambiguous is instead termed boundedly ambiguous in their terminology.
Let be a support of , we can construct a run automaton for , similar to the construction for an NFA on a support. As in the NFA case, by analysing the run automaton, we can build a finite system of inequalities and decide the -resolvability problem for finitely-ambiguous NPA.
Theorem 26.
The -resolvability problem for finitely-ambiguous NPA is decidable.
