On the Minimisation of Deterministic and History-Deterministic Generalised (Co)Büchi Automata
Abstract
We present a polynomial-time algorithm minimising the number of states of history-deterministic generalised coBüchi automata, building on the work of Abu Radi and Kupferman on coBüchi automata. On the other hand, we establish that the minimisation problem for both deterministic and history-deterministic generalised Büchi automata is NP-complete, as well as the problem of minimising at the same time the number of states and colours of history-deterministic generalised coBüchi automata.
Keywords and phrases:
Automata minimisation, omega-regular languages, good-for-games automataFunding:
Antonio Casares: Supported by the Polish National Science Centre (NCN) grant “Polynomial finite state computation” (2022/46/A/ST6/00072).Copyright and License:
![[Uncaptioned image]](x1.png)
2012 ACM Subject Classification:
Theory of computation Verification by model checkingEditors:
Jörg Endrullis and Sylvain SchmitzSeries and Publisher:

This document contains hyperlinks. On an electronic device, the reader can click on words or symbols (or just hover over them on some PDF readers) to see their definition.
1 Introduction
First introduced by Büchi to obtain the decidability of monadic second order logic over [14], automata over infinite words (also called -automata) have become a well-established area of study in Theoretical Computer Science. Part of its success is due to its applications to model checking (verify whether a system satisfies some given specifications) [5, 42, 24] and synthesis (given a set of specifications, automatically construct a system satisfying them) [13, 35]. In many of these applications, mainly in problems related to synthesis, non-deterministic models of automata are not well-suited, and costly determinisation procedures are usually needed [38].
In 2006, Henzinger and Piterman [26] proposed111Similar ideas had been previously investigated by Kupferman, Safra and Vardi [31], and Colcombet studied history-determinism in the context of cost functions [20]. a model of automata, called history-deterministic (HD)222These automata were first introduced under the name good-for-games (GFG). Currently, these two notions are no longer used interchangeably, although they coincide in the case of -automata. We refer to the survey [11] for further discussions., presenting a restricted amount of non-determinism so that they exactly satisfy the properties that are needed for applications in synthesis. Namely, these automata do not need to guess the future: an automaton is history-deterministic if it admits a strategy resolving the non-determinism on the fly, in such a way that the run built by the strategy is accepting whenever the input word belongs to the language of the automaton. Since their introduction, several lines of research have focused on questions such as the succinctness of history-deterministic automata [30, 18], the problem of recognising them [4, 8], or extensions to other settings [32, 9, 10].
Minimisation of automata stands as one of the most fundamental problems in automata theory, for various reasons. Firstly, for its applications: when employing algorithms that rely on automata, having the smallest possible ones is crucial for efficiency. Secondly, beneath the problem of minimisation lies a profoundly fundamental question: What is the essential information needed to represent a formal language? A cornerstone result about automata over finite words is that each regular language admits a unique minimal deterministic automaton, in which states corresponds to the residuals of the language (the equivalence classes of the Myhill-Nerode congruence). Moreover, this minimal automaton can be obtained from an equivalent deterministic automaton with states in time [27].
However, the situation is quite different in the case of -automata. Contrary to the case of finite words, the residuals of a language are not sufficient to construct a correct deterministic automaton in general. In 2010, Schewe proved that the minimisation of deterministic Büchi automata is -complete [39]. That appeared to be a conclusion to the minimisation problem, but a crucial aspect of his proof was that the -completeness is established for automata with the acceptance condition over states, and this proof does not generalise to transition-based automata. A surprising positive result was obtained in 2019 by Abu Radi and Kupferman: we can minimise history-deterministic coBüchi automata using transition-based acceptance in polynomial time [1]. One year later, Schewe showed that the very same problem becomes -complete if state-based acceptance is used [40]. Multiple other results have backed the idea that transition-based acceptance is a better-suited model; we refer to [16, Chapter VI] for a detailed discussion. The work of Abu Radi and Kupferman raised the question of what is the complexity of the minimisation problem for other classes of transition-based automata such as (history-)deterministic Büchi automata. Since then, to the best of our knowledge, the only further result concerning minimisation of transition-based automata is Casares’ -completeness proof for the problem of minimising deterministic Rabin automata [15].
In this paper, we focus our attention on generalised Büchi and generalised coBüchi automata, in which the acceptance condition is given, respectively, by conjunctions of clauses “see colour infinitely often”, and by disjunctions of “eventually avoid colour ”. Generalised (co)Büchi automata are as expressive as (co)Büchi automata, but they can be more succinct, due to their more complex acceptance condition. These automata appear naturally in the model-checking and synthesis of temporal properties [21, 25, 41]; for instance, SPOT’s LTL-synthesis tool transforms a given LTL formula into a generalised Büchi automaton [22, 33]. Also, many efficient algorithms for their emptiness check have been developed [36, 37, 6].
Several works have approached the problem of reducing the state-space of generalised Büchi automata, which is usually done either by the use of simulations [41, 29] (which do not yield minimal automata), or by the application of SAT solvers [23, 3]. However, to the best of our knowledge, no theoretical result about the exact complexity of this minimisation problem appears in the literature.
Contributions
We provide a polynomial-time minimisation algorithm for history-deterministic generalised coBüchi automata (Theorem 11). Our algorithm uses Abu Radi-Kupferman’s minimal history-deterministic coBüchi automaton as a starting point, and reduces the state-space of this automaton in an optimal way to use a generalised coBüchi condition.
We prove that the minimisation problem is -complete for history-deterministic generalised Büchi automata (Theorem 28), as well as for deterministic generalised Büchi and generalised coBüchi automata (Theorem 29). We remark that both the -hardness and the -upper bound are challenging. Indeed, to obtain that the problem is in , we first need to prove that a minimal HD generalised Büchi automaton only uses a polynomial number of output colours. Additionally, we adapt a proof from [19] to show that minimising at the same time the number of states and colours is -complete for all the previous models, including history-deterministic generalised coBüchi automata (Theorem 30).
We summarise the results about the state-minimisation of transition-based automata in Table 1.
We note that the complexity of recognising HD automata can be lifted from Büchi and coBüchi conditions to their generalised versions (Corollary 10). This result can be considered folklore, although we have not find it explicitly in the literature. In the long version, we also lift the characterisation based on the game from (co)Büchi automata to generalised ones (a similar remark was suggested in the conclusion of [8]).
State-minimality.
In this paper, we primarily focus our attention on the minimisation of the number of states of the automata. In Theorem 30 we also consider the minimisation of both the number of states and colours of the acceptance condition. We highlight that the decision on how we measure the size of the automata is orthogonal to putting the acceptance condition over transitions.
The reader may wonder why we focus on these quantities and not, e.g., on the number of transitions. This choice, which is standard in the literature ([2, 39]), is justified by various reasons. First, the number of transitions of an automaton is polynomial in the number of states. Indeed, we can assume that there are no two transitions between two states over the same input letter (see [18, Prop.18]), therefore, . Maybe more importantly, in the case of automata over finite words, each state of the minimal automaton carry a precise information about the language it recognises: a residual of it. Ideally, a construction for a state-minimal automaton for an -regular language should lead to an understanding of the essential information necessary to represent it.
The interest of minimising both the number of states and the number of colours comes from the fact that the number of colours can be exponential on the number of states, but the size of the representation of the automaton is polynomial in the sum of these quantities.
2 Preliminaries
The disjoint union of two sets is written . The empty word is denoted . A factor of a word is a word such that there exist words with . For an infinite word , we denote the set of letters occurring infinitely often in .
2.1 Automata
We let be a finite alphabet. An automaton is a tuple , where is its set of states, its initial state, its set of transitions, its output alphabet, a labelling with colours, and its acceptance condition. A state is called reachable if there exists a path from to . The size of an automaton is its number of states, written . We write if and .
A run on an infinite word is an infinite sequence of transitions with . It is accepting if the infinite word defined by , called the output of , belongs to .
The language of an automaton , denoted , is the set of words that admit an accepting run. We say that two automata and over the same alphabet are equivalent if .
An automaton is deterministic (resp. complete) if, for all , there exists at most (resp. at least) one such that . We note that if is deterministic, a word admits at most one run in .
2.2 Acceptance conditions
In this paper we will focus on automata using generalised Büchi and generalised coBüchi acceptance conditions. A generalised Büchi condition can be seen as a conjunction of Büchi conditions, while a generalised coBüchi condition can be seen as a disjunction of coBüchi conditions.
A generalised Büchi condition with colours is defined over the output alphabet , with a set of output colours, as
It contains sequences of sets of colours such that every colour is seen infinitely often. Usually, we take .
The dual condition is the generalised coBüchi condition with colours. That is, we define:
It contains sequences of sets of colours such that at least one colour is seen finitely often.
The size of the representation of an automaton using a generalised (co)Büchi condition with colours is ; such an automaton can be described in polynomial space in this measure.
A Büchi condition (resp. coBüchi condition) can be defined as a generalised Büchi (resp. generalised coBüchi) condition in which . In this case, we call Büchi transitions (resp. coBüchi transitions) the transitions such that . An automaton using an acceptance condition of type is called an X-automaton.
A language is (co)Büchi recognisable if there exists a deterministic (co)Büchi automaton such that recognises . These coincide with languages recognised by generalised (co)Büchi automata (see Corollary 9). We note that non-deterministic (generalised) Büchi automata are strictly more expressive, while non-deterministic (generalised) coBüchi automata are as expressive as deterministic ones [34].
2.3 History-determinism
An automaton is called history-deterministic (or HD for short), if there exists a function, called a resolver, that resolves the non-determinism of depending only on the prefix of the input word read so far. Formally, a resolver for an automaton is a function such that for all words , the sequence (called the run induced by over ) satisfies:
-
1.
is a run on in ,
-
2.
if , then is an accepting run.
An automaton is history-deterministic if it admits a resolver. We say that a (deterministic/history-deterministic) automaton is minimal if it has a minimal number of states amongst equivalent (deterministic/history-deterministic) automata.
Remark 1.
Example 2 (From [17, Ex. 2.3]).
Let and , that is, is the set of words that contain either or only finitely often.
In Figure 1 we show an automaton recognising that is not determinisable by prunning, that is, it cannot be made deterministic just by removing transitions.
We claim that this automaton is history-deterministic. First, we remark that the only non-deterministic choice appears when reading letter from the state . A resolver can be defined as follows: whenever we have arrived at from (by reading letter ), if we are given letter we go to state ; if we have arrived at from (by reading letter ), we will go to state . Therefore, if after some point letter (resp. letter ) does not appear, we will stay forever in state (resp. state ) and accept.
2.4 Residuals and prefix-independence
Let and . The residual of with respect to is the language
We write , and for the set of residuals of a language .
Given an automaton and a state , we denote the automaton obtained by setting as initial state, and we refer to as the language recognised by . We say that two states are equivalent, written , if they recognise the same language. We note the set of states equivalent to (we simply write when is clear from the context).
We say that an automaton is semantically deterministic if non-deterministic choices lead to equivalent states, that is, if for every state and pair of transitions , we have .
If is semantically deterministic and is a word labelling a path from the initial state to , then . We say then that is the residual associated to . For a residual we denote the set of states of recognising . We remark that for any state recognising .
We say that is prefix-independent if for all and , .
Remark 3.
A language is prefix-independent if and only if it has a single residual.
2.5 Morphisms of automaton structures
An automaton structure over an alphabet is a tuple , where . Let and be two automaton structures over the same alphabet. A morphism of automaton structures is a mappings such that for every , . We note that such a morphism induces a function sending to . We also denote this function , whenever no confusion arises, and denote a morphism of automaton structures by .
3 First properties and examples
We discuss a further example of a history-deterministic automaton and state some well-known facts about these automata that will be relevant for the rest of the paper.
3.1 A central example
The following automata will be used as a running example in Section 4.
Example 4.
Let be an alphabet of size , and let
On the left of Figure 2 we show a history-deterministic generalised coBüchi automaton recognising with just states (we show it for , but the construction clearly generalises to any ). The set of colours is , and we accept if eventually some colour is not produced. A resolver can be defined as follows: in a round-robin fashion, we bet that the factor that does not appear is , then , then . While factor is not seen, we will take transition whenever letter is read, to try to avoid colour . Whenever factor is read, we switch to the corresponding strategy with letter , trying to avoid colour . If eventually factor is not produced, for , then some colour will forever be avoided.
We show a deterministic coBüchi automaton for on the right of Figure 2. Applying the characterisation of Abu Radi and Kupferman [2] (see Lemma 15), we can prove that this automaton is minimal amongst HD coBüchi automata. More generally, we can prove that a minimal HD coBüchi automaton for has at least states , and in fact, in this case, this optimal bound can be achieved with a deterministic automaton.
3.2 Duality Büchi - coBüchi
Remark 5.
Let be a deterministic generalised Büchi automaton of size and using output colours. It suffices to replace the acceptance condition with to obtain a deterministic generalised coBüchi automaton of size and using output colours recognising the complement language . Symmetrically, we can turn any deterministic generalised coBüchi automaton into a deterministic generalised Büchi automaton with the same number of states and colours recognising the complement language. As a consequence, the minimisations of deterministic generalised Büchi automaton and deterministic generalised coBüchi automaton are linear-time-equivalent problems.
We highlight that the hypothesis of determinism in the previous remark is crucial. This duality property no longer holds for non-deterministic (or history-deterministic) automata.
Lemma 6.
There exists a history-deterministic generalised coBüchi automaton such that any history-deterministic generalised Büchi automaton recognising has strictly more states than .
Such an example is provided by the language from Example 4 (in the long version we prove that any non-deterministic generalised Büchi automaton recognising has at least states). Relatedly, for the non-generalised conditions, Kuperberg and Skrzypczak showed that the gap between an HD coBüchi and an HD Büchi automaton for the complement language can be exponential as well [30], using the link between complementation and determinisation of HD automata from [7, Thm 4].
3.3 From generalised (co)Büchi to (co)Büchi
The idea of this construction is to define a particular deterministic coBüchi automaton recognizing , and to associate it to the input generalised coBüchi automaton via a cascade composition (defined below) in order to obtain the wanted coBüchi automaton. We will now detail these different steps.
Deterministic coBüchi automaton for .
Let be a set of colours; for convenience, in the context of colours, we will use the symbol to denote addition modulo , in particular, . We build a deterministic coBüchi automaton over the alphabet recognising the language . It has as a state for each colour and contains the transitions , if , and , if , for all . The initial state is arbitrary.
We claim that the automaton recognises the language . First, we remark that the accepting runs of are exactly those that eventually remain forever in a state . Let . If is accepted by , then the run on eventually stays in a , so eventually does not contain colour , and . Conversely, if is rejected by , it takes all transitions infinitely often, so must contain all colours in infinitely often.
We define in a similar fashion a deterministic Büchi automaton recognising the language , simply by changing the acceptance condition of to .
Remark 7.
The automaton has states, but exponentially many transitions. This is made possible by the fact that its alphabet is exponential in the number of colours .
Cascade composition of automata.
Let and be two automata such that (i.e., is an automaton over the set of output colours of ). The cascade composition of and is the automaton over defined as:
with transitions if and .
Intuitively, given a word in , we feed the output of directly as input to , while keeping track of the progression in both automata. We accept according to the acceptance condition of .
Lemma 8 (Folklore).
Let be an automaton with acceptance condition , and let be a deterministic automaton over recognising . Then recognises , and the automaton is history-deterministic (resp. deterministic) if and only if is.
Thus, to convert a generalised coBüchi automaton to an equivalent coBüchi one, we can just compose it with . The symmetric result holds for generalised Büchi automata.
Corollary 9 (Folklore).
Let be a generalised coBüchi automaton using as output colours. The automaton is a coBüchi automaton equivalent to which is (history-)deterministic if and only if is. Moreover, can be computed in polynomial time in the size of the representation of . The same is true for generalised Büchi automata.
We note that has states, where , but it might have exponentially many transitions in . However, we underline that we can compute from in polynomial time in the size of its representation. Indeed, we just need to compose with the restriction of to transitions whose letters are subsets of colours that appear in .
Deciding history-determinism.
The problem of deciding whether an automaton is HD is known to be in for Büchi and coBüchi automata [30, 4, 8]. Combining this fact with Corollary 9, we directly obtain:
Corollary 10.
Given a generalised Büchi (resp. generalised coBüchi) automaton, it is in to decide whether it is history-deterministic.
4 Polynomial-time minimisation of HD generalised coBüchi automata
In this section we present one of the main contributions of the paper (Theorem 11): history-deterministic generalised coBüchi automata can be minimised in polynomial time.
Theorem 11.
Given a history-deterministic generalised coBüchi automaton, we can build in polynomial time in its representation an equivalent history-deterministic generalised coBüchi automaton with a minimal number of states.
The proof of this result strongly relies on the construction of minimal coBüchi automata by Abu Radi and Kupferman [2]. We will show that, for a coBüchi recognisable language , we can extract a minimal HD generalised coBüchi automaton for from its minimal HD coBüchi automaton.
In Section 4.1 we introduce some terminology and state the main property satisfied by the minimal HD coBüchi automaton of Abu Radi and Kupferman. We then present our construction, decomposing it in two steps for simplicity: first we construct a minimal HD generalised coBüchi automaton in the case of prefix-independent languages in Section 4.2, and in Section 4.3, we show how to get rid of the prefix-independence assumption.
4.1 Minimisation of HD coBüchi automata
Safe components and safe languages.
A path in a coBüchi automaton is safe if no coBüchi transition appears on it. Let be the automaton obtained by removing from all coBüchi transitions. A safe component of is a strongly connected component (i.e., a maximal set of states which are all reachable from each other) of ; formally, this is an automaton structure with and . We let be the set of safe components of .
We define the safe language of a state as:
Nice coBüchi automata.
We say that a coBüchi automaton is in normal form if all transitions between two different safe components are coBüchi transitions. We note that any coBüchi automaton can be put in normal form without modifying its language by setting all transitions between two different safe components to be coBüchi. We say that is safe deterministic if is a deterministic automaton. That is, if the non-determinism of appears exclusively in coBüchi transitions. We say that is nice if all its states are reachable, it is semantically deterministic, in normal form, and safe deterministic.
It is not difficult to see that any history-deterministic automaton can be assumed to be semantically deterministic. This means that different choices made by a resolver from the same state with different histories must be consistent with the residual, i.e. must lead to states accepting the same language, which is the language after reading a word . Kuperberg and Skrzypczak showed the more involved result that we can moreover assume safe determinism [30]. All in all, we have:
Lemma 13 ([30]).
Every history-deterministic coBüchi automaton can be turned in polynomial time into an equivalent nice HD coBüchi automaton such that:
-
,
-
For every safe component of , there is some safe component of with .
Although the second item of the previous proposition is not explicitly stated in [30], it simply follows from the fact that all the transformations used to turn into a nice automaton either add coBüchi transitions to or remove transitions from it. These operations can only subdivide safe components.
Minimal HD coBüchi automata.
We present the necessary conditions for the minimality of history-deterministic coBüchi automata identified by Abu Radi and Kupferman [2].
We say that a coBüchi automaton is safe centralised if for all equivalent states , if the safe languages of and are comparable for the inclusion relation ( or vice versa), then they are in the same safe component of . It is safe minimal if for all states , the equality implies .
Example 14.
Lemma 15 ([2, Lemma 3.5]).
Let be a nice, safe minimal and safe centralised HD coBüchi automaton. Then, for any equivalent nice HD coBüchi automaton there is an injection such that for every safe component , it holds that .
Minimality of such automata directly follows:
Corollary 16.
Let be a nice, safe minimal and safe centralised HD coBüchi automaton. Then, the number of states of is minimal among all HD coBüchi automata recognising the same language.
Theorem 17 ([2, Theorem 3.15]).
Any coBüchi recognisable language can be recognised by a nice, safe minimal and safe centralised HD coBüchi automaton . Moreover, such an automaton can be computed in polynomial time from any HD coBüchi automaton recognising .
4.2 Minimal HD generalised coBüchi automata: prefix-independent case
In this subsection, we show how to minimise history-deterministic generalised coBüchi automata recognising prefix-independent languages. The prefix-independence hypothesis will be removed in the next subsection.
Let be a prefix-independent coBüchi recognisable language, and let be a history-deterministic generalised coBüchi automaton recognising it.
Combining Corollary 9 and Theorem 17, we obtain that we can build in polynomial time the minimal HD coBüchi automaton for . Let be an enumeration of the safe components of , with and the sets of states and transitions of each safe component, respectively. We show how to build an HD generalised coBüchi automaton of size and using output colours.
Intuitively, will be the full automaton (it contains transitions between all pairs of states, for all input letters). Since , we can map each safe component to this full automaton via a morphism , and use (the non-appearance of) colour to accept runs that eventually would have stayed in the safe component in . That is, the transitions of that are “safe-for-colour ” will be exactly those in .
Formally, let with:
-
,
-
(any state can be chosen as initial),
-
,
-
.
Finally, we define the colour labelling . For each , let be any injective morphism of automaton structures (such a morphism exists since and is the full automaton structure). We put colour in a transition if and only if there is no transition such that . That is, .
Remark 18.
We remark that this colour labelling uses some arbitrary choices, namely, the way we map the different safe components of to the full automaton of size . In particular, there is no unique minimal HD generalised coBüchi automaton recognising . By a slight abuse of notation, we denote one automaton originated by this procedure.
Example 19.
The automaton on the left of Figure 2 (page 2) (almost) corresponds to this construction. Indeed, it has been obtained by assigning a colour to each safe component of (on the right) and superposing them in a -state automaton. To simplify its presentation, we have removed some unnecessary transitions of , that is why the automaton displayed is not the full-automaton.
Proposition 20 (Correctness).
Let be a prefix-independent language that is coBüchi recognisable. The automaton is history-deterministic and recognises .
Proof sketch.
If admits an accepting run in , then its run eventually does not produce some colour in its output. This means that, eventually, such a run is the -projection of a run in a safe component of , so . This is where we use prefix-independence: as soon as there is a witness that a suffix of is also a suffix of a word in , then the whole word is in as well.
A resolver for can be defined as follows: in a round-robin fashion we follow the different safe components of . If a colour is produced while we are trying to avoid it, we go back to and try to avoid colour by following the safe component . If a word belongs to , it eventually admits a safe path in , so it will be accepted by this resolver.
Proposition 21 (Minimality).
Let be a history-deterministic generalised coBüchi automaton recognising a prefix-independent language . Then, .
Proof.
Let be the set of output colours used by the acceptance condition of and let be the coBüchi automaton recognising presented in Section 3.3. By Corollary 9, is a history-deterministic automaton recognising . Moreover, the states of are a disjoint union such that:
-
,
-
all transitions leaving are coBüchi transitions going to , where .
Therefore, each safe component of is included in some , so . By Lemma 13, we can turn into a nice HD coBüchi automaton satisfying that none of its safe components is larger than .
By Lemma 15 there is an injection such that for all safe component of . In particular, if is a safe component of maximal size in , we obtain:
4.3 Minimal HD generalised coBüchi automata: general case
We now describe the polynomial-time construction for minimising a given HD generalised coBüchi automaton (without the prefix-independence assumption). For the optimality proof, we can reduce to the simplest prefix-independent case.
We fix an HD generalised coBüchi automaton recognising a language . As before, using Corollary 9 and the minimisation procedure of Abu Radi and Kupferman, we can obtain the minimal HD coBüchi automaton in polynomial time. We show how to convert it to an equivalent HD generalised coBüchi automaton of minimal size.
Let be all the distinct residual languages of , i.e., languages of the form for some finite word . The case corresponds to the prefix-independent case treated in Section 4.2. We note that these residuals induce a partition of the states of into , where the states in recognise . We assume that is the residual corresponding to the initial state of . Let be the safe components of , with and as sets of states and transitions, respectively. For each residual language , define as the largest number of states recognising appearing in a safe component of . That is,
We shall construct a language-equivalent HD generalised coBüchi automaton with states. Towards this, for each residual language , let be a set of elements. The automaton is given by:
-
.
-
(any state corresponding to the residual of the initial state of would work).
-
Let be a transition in , with and . Then, for all and .
-
.
One way of picturing is by taking the automaton of residuals of and making copies of the state corresponding to each residual (while keeping all transitions).
We now describe the colour labelling . Informally, each safe component is mapped into so that the states of are mapped into . These safe components are then “superimposed” upon each other and coloured appropriately, so that a run eventually staying in in corresponds to a run in that eventually avoids colour .
More formally, for , let be an injective morphism such that if . Such injective morphism does indeed exist, by the choice of and the fact that contains all transitions consistent with the residuals. The transitions of that are -safe are defined to be exactly those that are the image by of some transition in . That is, for , the labelling contains exactly the colours in .
Remark 22.
We remark that the automaton obtained in this way uses a polynomial number of output colours in the size of the minimal HD coBüchi automaton (see also long version). More precisely, the number of colours is the number of safe components of . However, this number of colours is not necessarily optimal (see Theorem 30).
The correctness of our construction, stated below, is proven similarly to Proposition 20.
Proposition 23 (Correctness).
Let be a coBüchi recognisable language. The automaton is history-deterministic and recognises .
In particular, the resolver for is defined as in Proposition 20: it follows the different safe components of in a round-robin fashion, by trying to avoid colour some colour while moving in , then if colour is seen it switches to , etc.
We explain how to obtain the minimality of , stated below. We reduce to the prefix-independent case, using a technique from [12].333An alternative proof scheme is to extend the proof of Proposition 21 to the general case, by taking into account the residuals of the language. For this, we need a refinement of Lemma 15, stating that the injection satisfies that, for every residual and safe component of , . The proof of Abu Radi and Kupferman [2] does indeed lead to this result, but it is not explicitly stated in this form. Full proofs can be found in the long version.
Proposition 24 (Minimality).
Let be a history-deterministic generalised coBüchi automaton recognising a language . Then, .
For each residual , we define the local alphabet at , as:
That is, if is a semantically deterministic automaton with states , then is the set of words that connect states in . Note that in general may be infinite, however this is harmless in this context, and we will freely allow ourselves to talk about automata over infinite alphabets. Also, is empty if and only if all the states of are transient, that is, they do not occur in any cycle of the automaton. For simplicity, in the following we assume that no state of is transient; the general case is treated in detail in the long version.
We define the localisation of to a residual as the language over the alphabet given by:
Remark 25.
For every residual , is a prefix-independent language. It corresponds to infinite words whose letters are in that is, going from to , and eventually avoid seeing some colour on such paths. The prefix-independence of follows from the fact that has only itself as residual, on alphabet .
Let be a semantically deterministic generalised coBüchi automaton with colours recognising . For each recurrent residual of we define to be the generalised coBüchi automaton over given by:
-
the set of states is , that is, the set of states of recognising .
-
the initial state is arbitrary,
-
the acceptance condition is (for the output colours of ),
-
there is a transition , with , , if there is a path from to labelled and producing the set of colours in .
Lemma 26.
The automaton recognises for each . Moreover, if is history-deterministic, so is .
Using the fact that (safe) paths between states in are the same in or in , combined with Lemma 15, we can prove:
Lemma 27.
is a minimal HD coBüchi automaton recognising . Moreover, a maximal safe component of this automaton has size .
5 NP-completeness of minimisation of deterministic and HD generalised Büchi automata
In this section we contrast the polynomial-time complexity previously obtained for minimising history-deterministic generalised coBüchi automata with the -hardness of the minimisation of deterministic generalised (co)Büchi and history-deterministic generalised Büchi automata.
Theorem 28.
The following problem is -complete: Given a history-deterministic generalised Büchi automaton and a number , decide whether there is an equivalent history-deterministic generalised Büchi automaton with at most states.
Theorem 29.
The minimisation of the number of states of deterministic generalised Büchi and deterministic generalised coBüchi automata is -complete.
We show -hardness of the minimisation problems in the deterministic and history-deterministic Büchi cases simultaneously. The -hardness for the deterministic coBüchi case follows directly. Our reduction is from a suitable version of the 3-colouring problem.
We further consider the problem of minimising both colours and states simultaneously for generalised (co)Büchi automata. For the automata classes appearing in the previous theorems (deterministic and history-deterministic generalised Büchi automata), it easily follows that this problem is -complete. We focus therefore in the case of history-deterministic generalised coBüchi, for which the minimisation of states has proven to be polynomial (Theorem 11). We show that, even in this case, minimising both states and colours is -complete.
Theorem 30.
The following problem is -complete: Given a history-deterministic generalised coBüchi automaton , and numbers and , decide whether there is an equivalent history-deterministic generalised coBüchi automaton with at most states and colours.
We obtain the lower bound by adapting the proof of -hardness of the minimising of Rabin pairs, given in [19], itself inspired from [28]. Details can be found in the long version.
5.1 Containment in and bounds on the necessary number of colours
In this section we address an important subtlety of our minimisation problems: We minimise the number of states, but the number of colours used by a generalised Büchi or generalised coBüchi automaton may be exponential in its number of states.
In order to show that the problems at hand are in , we need to show that the minimal deterministic and history-deterministic automata require a number of colours that is polynomial in the size of the input (that is, the number of states and colours of the input automaton). This turns out to be true, although not trivial. Full proofs are in the long version.
Lemma 31.
Let be a deterministic generalised Büchi automaton with states and colours. Then there is an equivalent deterministic generalised Büchi automaton with a minimal number of states and using colours.
Lemma 32.
Let be a history-deterministic generalised Büchi automaton with states and colours. Then there is an equivalent history-deterministic generalised Büchi automaton with a minimal number of states and using colours.
This allows us to obtain an algorithm as we only need to guess an automaton with polynomially many states and colours, and check equivalence with the input automaton. The latter test can be done in polynomial time (see for instance [40, Thm. 4]).
As an additional result, we show that the previous lemmas do not hold for general non-deterministic automata: minimising an automaton may blow up its number of colours.
Proposition 33.
There exists a family of non-deterministic generalised Büchi automata such that for all , uses states and colours and a minimal automaton equivalent to requires colours.
5.2 Hardness of state minimisation
We provide a reduction from the 3-colouring problem. We construct from a given graph a deterministic automaton such that:
-
If is 3-colourable then there is a 3-state deterministic automaton equivalent to , and
-
if is not 3-colourable then there is no automaton (deterministic or not) with 3 states equivalent to .
This establishes the hardness of state-minimisation for deterministic and history-deterministic automata simultaneously. The full proof is in the long version. We only present here the languages we use and a sketch of the first item. The second item is obtained by a refined case analysis over the cycles of generalised Büchi automata with three states.
Given an undirected graph , we define the neighbourhood of a vertex as the set , and its strict neighbourhood as .
We consider the alphabet . For each , we define the language:
In words, a sequence of nodes is in if for all it either has infinitely many factors or sees a vertex that is not a neighbour of infinitely many times.
The first item is proven by the following more general lemma. We actually show that from a -colouring of we can build a deterministic automaton with states for . This also allows us to construct the automaton by applying this lemma on a trivial -colouring.
Lemma 34.
For all graph and , if is -colourable then there exists a complete deterministic generalised Büchi automaton with states which recognises .
Proof sketch.
Suppose is -colourable, let be a -colouring of . We define the deterministic generalised Büchi automaton as follows:
-
The set of states is , we pick any state as the initial one.
-
For and , the -transition from is .
-
The set of output colours is , hence the output alphabet is .
-
If , the transition is coloured with . Transitions of the form are coloured with .
It is then quite straightforward to show that a word is accepted by if and only if for each it goes infinitely many times through the -loop on or sees infinitely many times vertices outside of . The structure of the automaton ensures that those words are exactly the ones in . In particular, the fact that for all neighbours and implies that we cannot go through the loop on without reading a or a non-neighbour of just before. Figure 3 shows an example of this construction.
6 Conclusion
We believe that one of the key novel insights of this work is to compare the complexity of the minimisation of HD generalised coBüchi automata (polynomial) with both HD generalised Büchi automata and deterministic models (-complete). For history-deterministic and deterministic Büchi automata the minimisation problem is still open; our results are an important step in this direction, and seem to indicate that the polynomial-time minimisation algorithm for the HD coBüchi case will not extend to the Büchi or the deterministic case.
References
- [1] Bader Abu Radi and Orna Kupferman. Minimizing GFG transition-based automata. In ICALP, volume 132 of LIPIcs, pages 100:1–100:16, 2019. doi:10.4230/LIPIcs.ICALP.2019.100.
- [2] Bader Abu Radi and Orna Kupferman. Minimization and canonization of GFG transition-based automata. Log. Methods Comput. Sci., 18(3), 2022. doi:10.46298/lmcs-18(3:16)2022.
- [3] Souheib Baarir and Alexandre Duret-Lutz. Mechanizing the minimization of deterministic generalized Büchi automata. In FORTE, volume 8461 of Lecture Notes in Computer Science, pages 266–283, 2014. doi:10.1007/978-3-662-43613-4_17.
- [4] Marc Bagnol and Denis Kuperberg. Büchi good-for-games automata are efficiently recognizable. In FSTTCS, page 16, 2018. doi:10.4230/LIPICS.FSTTCS.2018.16.
- [5] Christel Baier and Joost-Pieter Katoen. Principles of model checking. MIT Press, 2008.
- [6] Frantisek Blahoudek, Alexandre Duret-Lutz, and Jan Strejcek. Seminator 2 can complement generalized Büchi automata via improved semi-determinization. In CAV, volume 12225 of Lecture Notes in Computer Science, pages 15–27, 2020. doi:10.1007/978-3-030-53291-8_2.
- [7] Udi Boker, Denis Kuperberg, Orna Kupferman, and Michal Skrzypczak. Nondeterminism in the presence of a diverse or unknown future. In Automata, Languages, and Programming - 40th International Colloquium, ICALP 2013, volume 7966 of Lecture Notes in Computer Science, pages 89–100. Springer, 2013. doi:10.1007/978-3-642-39212-2_11.
- [8] Udi Boker, Denis Kuperberg, Karoliina Lehtinen, and Michał Skrzypczak. On succinctness and recognisability of alternating good-for-games automata. CoRR, abs/2002.07278, 2020. arXiv:2002.07278.
- [9] Udi Boker and Karoliina Lehtinen. Good for games automata: From nondeterminism to alternation. In CONCUR, volume 140, pages 19:1–19:16, 2019. doi:10.4230/LIPIcs.CONCUR.2019.19.
- [10] Udi Boker and Karoliina Lehtinen. History determinism vs. good for gameness in quantitative automata. In FSTTCS, volume 213, pages 38:1–38:20, 2021. doi:10.4230/LIPIcs.FSTTCS.2021.38.
- [11] Udi Boker and Karoliina Lehtinen. When a little nondeterminism goes a long way: An introduction to history-determinism. ACM SIGLOG News, 10(1):24–51, 2023. doi:10.1145/3584676.3584682.
- [12] Patricia Bouyer, Antonio Casares, Mickael Randour, and Pierre Vandenhove. Half-positional objectives recognized by deterministic Büchi automata. In CONCUR, volume 243, pages 20:1–20:18, 2022. doi:10.4230/LIPIcs.CONCUR.2022.20.
- [13] J. Richard Büchi and Lawrence H. Landweber. Solving sequential conditions by finite-state strategies. Transactions of the American Mathematical Society, 138:295–311, 1969. URL: http://www.jstor.org/stable/1994916.
- [14] J. Richard Büchi. On a decision method in restricted second order arithmetic. Proc. Internat. Congr. on Logic, Methodology and Philosophy of Science, pages 1–11, 1962.
- [15] Antonio Casares. On the minimisation of transition-based Rabin automata and the chromatic memory requirements of Muller conditions. In CSL, volume 216, pages 12:1–12:17, 2022. doi:10.4230/LIPIcs.CSL.2022.12.
- [16] Antonio Casares. Structural properties of automata over infinite words and memory for games (Propriétés structurelles des automates sur les mots infinis et mémoire pour les jeux). PhD thesis, Université de Bordeaux, France, 2023. URL: https://theses.hal.science/tel-04314678.
- [17] Antonio Casares, Thomas Colcombet, Nathanaël Fijalkow, and Karoliina Lehtinen. From Muller to Parity and Rabin Automata: Optimal Transformations Preserving (History) Determinism. TheoretiCS, Volume 3, April 2024. doi:10.46298/theoretics.24.12.
- [18] Antonio Casares, Thomas Colcombet, and Karoliina Lehtinen. On the size of good-for-games Rabin automata and its link with the memory in Muller games. In ICALP, volume 229, pages 117:1–117:20, 2022. doi:10.4230/LIPIcs.ICALP.2022.117.
- [19] Antonio Casares and Corto Mascle. The complexity of simplifying -automata through the alternating cycle decomposition. CoRR, abs/2401.03811, 2024. arXiv:2401.03811, doi:10.48550/arXiv.2401.03811.
- [20] Thomas Colcombet. The theory of stabilisation monoids and regular cost functions. In ICALP, pages 139–150, 2009. doi:10.1007/978-3-642-02930-1_12.
- [21] Costas Courcoubetis, Moshe Y. Vardi, Pierre Wolper, and Mihalis Yannakakis. Memory-efficient algorithms for the verification of temporal properties. Formal Methods Syst. Des., 1(2/3):275–288, 1992. doi:10.1007/BF00121128.
- [22] Alexandre Duret-Lutz, Alexandre Lewkowicz, Amaury Fauchille, Thibaud Michaud, Etienne Renault, and Laurent Xu. Spot 2.0 - A framework for LTL and -automata manipulation. In ATVA, volume 9938 of Lecture Notes in Computer Science, pages 122–129, 2016. doi:10.1007/978-3-319-46520-3_8.
- [23] Rüdiger Ehlers. Minimising deterministic Büchi automata precisely using SAT solving. In Theory and Applications of Satisfiability Testing - SAT, volume 6175 of Lecture Notes in Computer Science, pages 326–332, 2010. doi:10.1007/978-3-642-14186-7_28.
- [24] Javier Esparza, Orna Kupferman, and Moshe Y. Vardi. Verification. In Jean-Éric Pin, editor, Handbook of Automata Theory, pages 1415–1456. European Mathematical Society Publishing House, Zürich, Switzerland, 2021. doi:10.4171/AUTOMATA-2/16.
- [25] Rob Gerth, Doron A. Peled, Moshe Y. Vardi, and Pierre Wolper. Simple on-the-fly automatic verification of linear temporal logic. In IFIP, volume 38, pages 3–18, 1995.
- [26] Thomas A. Henzinger and Nir Piterman. Solving games without determinization. In Computer Science Logic, pages 395–410, 2006. doi:10.1007/11874683_26.
- [27] John E. Hopcroft. An n log n algorithm for minimizing states in a finite automaton. Technical report, Stanford University, 1971. doi:10.5555/891883.
- [28] Christopher Hugenroth. Zielonka DAG acceptance, regular languages over infinite words. In DLT, 2023.
- [29] Sudeep Juvekar and Nir Piterman. Minimizing generalized Büchi automata. In CAV, pages 45–58, 2006. doi:10.1007/11817963_7.
- [30] Denis Kuperberg and Michał Skrzypczak. On determinisation of good-for-games automata. In ICALP, pages 299–310, 2015. doi:10.1007/978-3-662-47666-6_24.
- [31] Orna Kupferman, Shmuel Safra, and Moshe Y. Vardi. Relating word and tree automata. In LICS, pages 322–332, 1996. doi:10.1109/LICS.1996.561360.
- [32] Karoliina Lehtinen and Martin Zimmermann. Good-for-games -pushdown automata. In LICS, pages 689–702, 2020. doi:10.1145/3373718.3394737.
- [33] Thibaud Michaud and Maximilien Colange. Reactive synthesis from LTL specification with Spot. In SYNT@CAV, Electronic Proceedings in Theoretical Computer Science, 2018.
- [34] Satoru Miyano and Takeshi Hayashi. Alternating finite automata on omega-words. Theor. Comput. Sci., 32:321–330, 1984. doi:10.1016/0304-3975(84)90049-5.
- [35] Amir Pnueli and Roni Rosner. On the synthesis of a reactive module. In POPL, pages 179–190, 1989. doi:10.1145/75277.75293.
- [36] Etienne Renault, Alexandre Duret-Lutz, Fabrice Kordon, and Denis Poitrenaud. Three SCC-based emptiness checks for generalized Büchi automata. In LPAR, volume 8312 of Lecture Notes in Computer Science, pages 668–682, 2013. doi:10.1007/978-3-642-45221-5_44.
- [37] Etienne Renault, Alexandre Duret-Lutz, Fabrice Kordon, and Denis Poitrenaud. Variations on parallel explicit emptiness checks for generalized Büchi automata. Int. J. Softw. Tools Technol. Transf., 19(6):653–673, 2017. doi:10.1007/S10009-016-0422-5.
- [38] Schmuel Safra. On the complexity of -automata. In FOCS, pages 319–327, 1988. doi:10.1109/SFCS.1988.21948.
- [39] Sven Schewe. Beyond hyper-minimisation—minimising DBAs and DPAs is NP-complete. In FSTTCS, volume 8, pages 400–411, 2010. doi:10.4230/LIPIcs.FSTTCS.2010.400.
- [40] Sven Schewe. Minimising Good-For-Games automata is NP-complete. In FSTTCS, volume 182, pages 56:1–56:13, 2020. doi:10.4230/LIPIcs.FSTTCS.2020.56.
- [41] Fabio Somenzi and Roderick Bloem. Efficient Büchi automata from LTL formulae. In CAV, volume 1855 of Lecture Notes in Computer Science, pages 248–263, 2000. doi:10.1007/10722167_21.
- [42] M.Y. Vardi and P. Wolper. Reasoning about infinite computations. Information and Computation, 115(1):1–37, 1994. doi:10.1006/inco.1994.1092.