Distributed Automata and Logic

(1)

HAL Id: tel-01827435

https://hal.archives-ouvertes.fr/tel-01827435

Submitted on 2 Jul 2018

HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci-entific research documents, whether they are pub-lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Distributed under a Creative Commons Attribution| 4.0 International License

Fabian Reiter

To cite this version:

Fabian Reiter. Distributed Automata and Logic. Formal Languages and Automata Theory [cs.FL]. Université Paris Diderot; Université Sorbonne Paris Cité, 2017. English. �tel-01827435�

(2)

δ

∶

Q

×

2 Q

→

Q

PhD thesis in Theoretical Computer Science

Distributed Automata and Logic

Fabian Reiter

Dissertation defense on 12 December 2017.

Olivier Carton supervisor

Bruno Courcelle examiner

Pierre Fraigniaud examiner

Nicolas Ollinger examiner

Jukka Suomela reviewer

Christine Tasson examiner

Wolfgang Thomas reviewer

É c o l e D o c to r a l e 3 8 6

(3)

(4)

PhD thesis in Theoretical Computer Science

Distributed Automata and Logic

Fabian Reiter

(5)

Contact address: [email protected]

(6)

Abstract

Distributed automataare finite-state machines that operate on finitedirected graphs. Acting as synchronous distributed algorithms, they use their inputgraphas a network in which identical processors communicate for a possibly infinite number of syn-chronous rounds. For thelocalvariant of those automata, where the number of rounds is bounded by a constant, Hella et al. (2012, 2015) have established alogical

characterization in terms of basicmodal logic. In this thesis, we provide similar

logicalcharacterizations for two more expressive classes ofdistributed automata. The first class extendslocal automatawith a global acceptance conditionand the ability toalternatebetween nondeterministic and parallelcomputations. We show that it isequivalenttomonadic second-order logicongraphs. By restricting

transitionsto benondeterministicordeterministic, we also obtain two strictly weaker variants for which the emptiness problem is decidable.

Our second class transfers the standard notion ofasynchronous algorithmto the setting ofnonlocal distributed automata. The resulting machines are shown to be

equivalentto a small fragment of least fixpoint logic, and more specifically, to a

restricted variant of the modalµ-calculusthat allows least fixpointsbut forbids greatest fixpoints. Exploiting the connection withlogic, we additionally prove that the expressive power of thoseasynchronous automatais independent of whether or not messages can be lost.

We then investigate the decidability of theemptiness problemfor several classes ofnonlocal automata. We show that the problem is undecidable in general, by simulating a Turing machine with adistributed automatonthat exchanges the roles of space and time. On the other hand, the problem is found to be decidable in logspace for a class offorgetful automata, where thenodessee the messages received from theirneighborsbut cannot remember their ownstate.

As a minor contribution, we also give new proofs of the strictness of severalset quantifieralternation hierarchies that are based onmodal logic.

Keywords. Automata, Distributed algorithms, Modal logic, Monadic second-order logic, Graphs.

(9)

(10)

Résumé

Les automates distribués sont des machines à états finis qui opèrent sur des graphes orientés finis. Fonctionnant en tant qu’algorithmes distribués synchrones, ils utilisent leur graphe d’entrée comme un réseau dans lequel des processeurs identiques com-muniquent entre eux pendant un certain nombre (éventuellement infini) de rondes synchrones. Pour la variantelocale de ces automates, où le nombre de rondes est borné par une constante, Hella et al. (2012, 2015) ont établi une caractérisation logique par des formules de la logique modale de base. Dans le cadre de cette thèse, nous présentons des caractérisations logiques similaires pour deux classes d’automates distribués plus expressives.

La première classe étend les automates locaux avec une condition d’acceptation globale et la capacité d’alterner entre des modes de calcul non-déterministe et par-allèle. Nous montrons qu’elle est équivalente à la logique monadique du second ordre sur les graphes. En nous restreignant à des transitions non-déterministes ou déterministes, nous obtenons également deux variantes d’automates strictement plus faibles pour lesquelles le problème du vide est décidable.

Notre seconde classe adapte la notion standard d’algorithme asynchrone au cadre des automates distribués non-locaux. Les machines résultantes sont prouvées équiv-alentes à un petit fragment de la logique de point fixe, et plus précisément, à une variante restreinte duµ-calcul modal qui autorise les plus petits points fixes mais interdit les plus grands points fixes. Profitant du lien avec la logique, nous montrons aussi que la puissance expressive de ces automates asynchrones est indépendante du fait que des messages puissent être perdus ou non.

Nous étudions ensuite la décidabilité du problème du vide pour plusieurs classes d’automates non-locaux. Nous montrons que le problème est indécidable en général, en simulant une machine de Turing par un automate distribué qui échange les rôles de l’espace et du temps. En revanche, le problème s’avère décidable en logspace pour une classe d’automates oublieux, où les nœuds voient les messages reçus de leurs voisins, mais ne se souviennent pas de leur propre état.

Finalement, à titre de contribution mineure, nous donnons également de nouvelles preuves de séparation pour plusieurs hiérarchies d’alternance de quantificateurs basées sur la logique modale.

Mots-clés. Automates, Algorithmes distribués, Logique modale, Logique monadi-que du second ordre, Graphes.

(11)

(12)

Acknowledgments

First and foremost, I would like to thank my advisor, Olivier Carton, for his continuous support during the past three years. This included finding a scholarship for me, spending countless hours with me in front of a whiteboard, as well as helping me in the writing of several papers and this thesis. I am especially grateful for the immense freedom he granted me throughout the entire period, letting me pursue ideas of my own, but at the same time always being available for discussion. He provided guidance whenever I needed it, but never exerted pressure, gave very good advice, but always let me decide for myself. In my opinion, this is exactly how a doctoral thesis should be supervised, but it can by no means be taken for granted. I therefore consider myself very fortunate to have had Olivier as my advisor.

My sincere thanks extend to Bruno Courcelle, Pierre Fraigniaud, Nicolas Ollinger, Jukka Suomela, Christine Tasson, and Wolfgang Thomas, who kindly accepted to be part of my thesis committee.

Jukka Suomela and Wolfgang Thomas did me the great honor of reviewing a preliminary version of the manuscript. They gave detailed and extremely flattering feedback, and both made an important remark that led to a major improvement of this document: I had failed to include a discussion of perspectives for future research. This shortcoming has now been addressed by the addition ofChapter 7. Furthermore, Wolfgang compiled a very helpful collection of suggestions, which I have tried to incorporate into the present version.

Bruno Courcelle graciously gave his time to read my master’s thesis in 2014, al-though he had never heard of me before. He then informed Géraud Sénizergues, who most kindly invited me to the final conference of the frec project in Marseille. This opened the door for me into the French community of automata theory, especially since I met my future doctoral advisor at that conference. Thus, it is indirectly through Bruno that I came to Paris.

There, at irif (formerly liafa), Pierre Fraigniaud showed a very kind interest in my work and opened another door for me, this time into the community of distributed computing. He did so by referring to my first paper in several of his own collaborations and by providing various opportunities for me to meet his colleagues, in particular at two international workshops in Bertinoro and Oaxaca. The latter was made possible through a joint effort of Pierre and Sergio Rajsbaum.

In addition to the committee, I am grateful to Fabian Kuhn and Andreas Podelski, who supervised my master’s thesis (the starting point for the present thesis), to Antti Kuusisto, who collaborated with me on the work inChapter 5, to Laurent Feuilloley,

(13)

who proofread and corrected the overview of distributed decision inSection 1.1.2, to Charles Paperman, who was the first to tell me that I was unknowingly working with some kind ofmodal logic, to Nicolas Bacquey, who informed me that exchanging space and time is a common technique in cellular automata theory, and to Thomas Colcombet, who developed theknowledgepackage and encouraged me to use it here.

F

We have just crossed the dividing line, where I stop mentioning people by name. This may seem hasty, or even harsh, but there are two good reasons. First, I value my privacy very much and do not want to share personal details in a document that will be publicly available on the Internet. Second, the larger the circle of people I include, the greater the risk of forgetting someone. A simple rule that helps to avoid both of these issues is to mention only people who stand in some direct professional relation to the thesis. Nevertheless, many more have helped me over the years and had a tremendous influence on my life and work. I therefore sincerely hope not to offend anyone by expressing my gratitude in the following simplistic manner:

(14)

1

Introduction

The present thesis aims to contribute to the recently initiated development of a descriptive complexity theory for distributed computing.

What does this mean? Descriptive complexity [Imm99] basically compares the

expressive powers of certain classes ofalgorithms, or abstract machines, We identify algorithms with abstract machines.

with those of certain classes of logicalformulas. The Holy Grail, so to speak, is to establish

equivalencesof the form:

“Algorithm classA has exactly the same power asformulaclassΦ.”

Probably the most famous result in this area is Fagin’s theorem from 1974 [Fag74], which roughly states that agraph propertycan be recognized by a nondeterministic Turing machine in polynomial time if and only if it can bedefinedby aformulaof ex-istential second-order logic. The theorem thereby provides a logical characterization of the complexity class nptime.

Distributed computing [Lyn96,Pel00], on the other hand, studies networks com-posed of several interconnected processors that share a common goal. The processors communicate with each other by passing messages along the links of the network in order to collectively solve some computational problem. In many cases, this is a

graphproblem, where the considered problem instance is precisely thegraphdefined by the network itself. All processors run the same algorithm concurrently, and often make no prior assumptions about the size and topology of thegraph. Typical prob-lems that can be solved by suchdistributed algorithms includegraph coloring, leader election, and the construction of spanning trees and maximal independent sets.

Now, the ultimate objective that motivates this thesis is to develop an extension of descriptive complexity for the classes of algorithms considered in distributed computing. This means that we seek to establishequivalencesof the form:

“Distributed algorithm classA has the same power asformulaclassΦ.”

Distributed algorithms are abstract machines that communicate.

However, such a statement can only be substantial if we have a precise definition of classA. Therefore, we will formally represent distributed algorithms as abstract machines, instead of the more common, but informal, representations in pseudocode.

(15)

Why is this interesting? First and foremost, a descriptive complexity theory for distributed computing would offer the same benefits as its classical counterpart does for sequential computing:

a. If distributed algorithm classA turns out to beequivalent toformulaclassΦ, then this provides strong evidence for the naturalness of both classes. Indeed, the definition of any mathematical device may, by itself, seem arbitrary. Why should distributed machines communicate precisely that way? Why should logicalformulas

contain precisely those components? But if two devices, that appear rather different on the surface, turn out to be descriptions of the exact same thing, then this is unlikely to be pure coincidence.

b. Connecting two seemingly unrelated fields – here, distributed computing and logic – can provide new insights into both fields. Some proofs might be easier to perform if one adopts the point of view of one setting rather than the other.

Formal logic dates back to the mid-19th century, while distributed com-puting started in the 1970s/1980s.

Furthermore, some open questions in one field might already have well-known answers in the other. Especially the field of distributed computing could benefit from this, as it is more than a century younger than formal logic, and therefore has had less time to evolve.

Second, distributed computing also brings an interesting new perspective to the field of descriptive complexity itself:

c. Distributed algorithms can be evaluated on the same input as logicalformulas, without any need for encoding that input. More precisely, the network in which a distributed algorithm is executed may be considered identical to thestructureon which the truth of a correspondingformulais evaluated. This stands in sharp contrast to classical descriptive complexity theory. For instance, in the case of Fagin’s theorem, the input of a Turing machine is a binary string that encodes a finitegraphin form of an adjacency matrix. Hence, the equivalence of nondeterministic polynomial-time Turing machines and existential second-order logic is actually stated with respect to such an encoding.

1.1 Background

Let us now take a step back and put the subject into context. We start with a brief summary of some classical results in automata theory, and then turn to more recent developments in distributed computing.

1.1.1 Related work in automata theory

Although the field of descriptive complexity theory really started with Fagin’s theorem in the 1970s, the idea of characterizing abstract machines through logi-calformulas had already appeared earlier in automata theory. In the early 1960s, Büchi [Büc60], Elgot [Elg61] and Trakhtenbrot [Tra61] discovered independently of each other that the regular languages, which are recognized byfinite automata on

words, are precisely the languagesdefinableinmonadic second-order logic, ormsol

(see, e.g., [Tho97b, Thm 3.1]). The latter is an extension offirst-order logic, which in addition to allowing quantification over elements of a givendomain(e.g., positions in aword), also allows to quantify over sets of such elements. Along with several other equivalent characterizations, in particular through regular expressions [Kle56], regular grammars [Cho56], and finite monoids [Ner58], theequivalencebetween au-tomata and logic helped to legitimize regularity as a highly natural concept in formal

(16)

1.1 Background 3

language theory (cf.Item a, above). Furthermore, it proved that the satisfiability and validity problems formsolonwordsare decidable, because so are the corresponding problems for finite automata. In this way, the field of logic directly benefited from the connection with automata theory (cf.Item b). Nowadays, such connections also play a central role in model checking, where one needs to decide whether a system, represented by an automaton, satisfies a given specification, expressed as a logical

formula.

About a decade later, the result was generalized fromwordstolabeled treesby Thatcher and Wright [TW68] and Doner [Don70] (see, e.g., [Tho97b, Thm 3.6]). The corresponding tree automata can be seen as a canonical extension of finite automata totrees; as far asmsolis concerned, the generalization totreesis even more straightforward, since bothwordsandtreesare merely special cases of the relationalstructures on which logicalformulas are usually evaluated. The other characterizations of regular languages can also be generalized fromwordstotrees

in a natural manner, and quite remarkably, they all remain equivalent ontrees(see, e.g., [CDG+08]). Hence, the notion of regularity extends directly totree languages. Moreover, similarequivalenceshave been established for several other generaliza-tions ofwords, such as nested words (see [AM09]) and Mazurkiewicz traces (see, e.g., [DM97]).

In contrast, the situation becomes far more complicated if we expand our field of interest to arbitrary finitegraphs(possibly withnode labelsand multipleedge relations). Although some of the characterizations mentioned above can be general-ized tographsin a meaningful way, they are, in general, no longer equivalent. The logical approach is certainly the easiest to generalize, sincegraphsare yet another special case of relationalstructures. While onwordsandtreesthe existential frag-ment ofmsol(emsol) is already sufficient to characterize regularity, it is strictly

less expressive than fullmsolongraphs, Fagin’s result was later extended by Matz, Schweikardt and Thomas to yield a complete separation of themsol quantifieralternation hierarchy (see [MST02]).

as has been shown by Fagin in [Fag75]. Similarly, the algebraic approach (based on monoids) has been adapted tographs

by Courcelle in [Cou90], and it turns out thatmsolis strictly less powerful than his notion of recognizability. (The latter is defined in terms of homomorphisms into many-sorted algebras that are finite in each sort.) A common pattern that emerges from such results is that the different characterizations of regularity drift apart as the complexity of the consideredstructuresincreases. In this sense, regularity cannot be considered a natural – or even well-defined – property ofgraph languages.

To complicate matters even further, the automata-theoretic characterization which is instrumental in the theory ofwordandtree languages, does not seem to have a natural counterpart ongraphs. Awordortreeautomaton can scan its entire input in a single canonical traversal, which is completely determined by the structure of the input (i.e., left-to-right, forwords, and bottom-up, fortrees). On arbitrarygraphs, however, there is no sense of a global direction that the automaton could follow, especially since we do not even requireconnectivityor acyclicity. This is one of the reasons why much research in the area ofgraph languageshas focused onmsol. In the words of Courcelle and Engelfriet [CE12, p. 3]:

. . .monadic second-order logiccan be viewed as playing the role of “finite automata ongraphs” . . .

Another approach, investigated by Thomas in [Tho91] and [Tho97a], is to non-deterministically assign a state of the automaton to eachnodeof the graph, and then check that this assignment satisfies certain local “transition” conditions for

(17)

eachnode(specified with respect toneighboring nodeswithin a fixed radius) as well as certain global occurrence conditions at the level of the entiregraph. The

graphacceptors devised by Thomas turn out to be equivalent toemsolongraphsof bounded degree. Following up on this idea in [SB99], Schwentick and Barthelmann have also suggested a more general model, which remains very close to a normal form ofemsol, but overcomes the constraint of boundedness on the degree. Both of thesegraphautomaton models are legitimate generalizations of classical finite automata, in the sense that they are equivalent to them and can easily simulate them if we restrict the input to (graphsrepresenting)wordsortrees. However, on arbitrary

graphs, they are less well-behaved, which is a direct consequence of theirequivalence

withemsol. In particular, they do not satisfy closure under complementation, and their emptiness problem is undecidable. It is worth noting that both models are somewhat similar to the local distributed algorithms considered in the next section, insofar as they take into account the local view that eachnodehas of its fixed-radius neighborhood. This connection has already been recognized and exploited by Göös and Suomela in [GS11,GS16]; we will mention it again below.

1.1.2 Related work in distributed computing

Rather surprisingly, the idea of extending descriptive complexity theory to the setting of distributed computing seems to be relatively new. The first research in that direction (of which the author is aware) started in the early 2010s as a collaboration between the Finnish communities of logic and distributed algorithms.

In [HJK+12,HJK+15], Hella et al. have presented a systematic study of several models of distributed computing that impose restrictions of varying degrees on the communication between thenodesof a network. Their most permissive model corresponds to the well-established port-numbering model, where everynodehas a separate communication channel with each of itsneighborsand is guaranteed that the messages sent and received through that channel relate consistently to the sameneighbor; the network is anonymous in the sense thatnodesare not equipped with unique identifiers. In the nomenclature of [HJK+12,HJK+15], the class ofgraph

problems solvable in this model by deterministicsynchronous algorithms is denoted by vv_c.

The classes of Hella et al.:

Incoming Outgoing vvc vector vector vv — — mv multiset — sv set — vb vector singleton mb multiset — sb set —

Here, “synchronous” means that allnodesof the network share a global clock, thereby allowing the computation to proceed in an infinite sequence of rounds; in each round, all thenodessimultaneously exchange messages with theirneighbors, and then update their local state based on the newly obtained information. Next, by dropping the channel-consistency guarantee, one obtains the class vv, where in each round, everynodesees a vector consisting of all the incoming messages received from itsneighbors, and generates a vector of outgoing messages that are sent to theneighbors; the difference with vv_cis that the two vectors are not necessarily sorted in the same order, so thenodecannot assume that theneighborwho sends thei-th incoming message is the same who receives the i-th outgoing message. (However, the sorting orders do not change throughout the rounds.) Communication is further restricted in the classes mv and sv, where the vector of incoming messages is replaced by a multiset and a set, respectively. In the former case, anodecannot identify the senders of its incoming messages, whereas in the latter, it cannot even distinguish between several identical messages. Similarly, the classes vb, mb, and

sbare characterized by the fact that the outgoing vector is replaced by a singleton, meaning that anodemust broadcast the same message to all of itsneighbors.

(18)

1.1 Background 5

The main result of [HJK+12,HJK+15] is that the preceding classes satisfy the linear order

sb⫋ mb = vb ⫋ sv = mv = vv ⫋ vvc.

The same order holds for the so-called local (or constant-time) versions of these classes, which contain only thosegraphproblems that can be solved in a constant number of communication rounds, regardless of the size of the network. (For a relatively recent survey of local algorithms, see [Suo13].)

Most relevant for the present thesis, the same paper also establishes a very natural correspondence between these local classes and several variants ofmodal logic. In particular, agraph propertylies insb₍₁₎, the local version ofsb, if and only if it can be

definedby aformulaofbackward modal logic. Using the backward ver-sion of standardmodal logicis merely a presenta-tional choice, motivated by the intuition that the messages of a distributed algorithm should flow in the same direction as the network links on which they travel. The presenta-tion in [HJK+12,HJK+15] is a bit different.

Just like a distributed algorithm, such aformulais evaluated from the local point of view of a particularnodein the input

graph. In order to make a statement about theincoming neighborhoodof thatnode,

backward modal logicallows to move the current point of evaluation to one of the

incoming neighborsby means of a special operator, calledbackward modality. The key insight of Hella et al. is that the nesting depth of thesemodalitiescorresponds precisely to the running time of the local algorithms that solve problems insb₍₁₎. With this idea in mind, it is possible to derive similar characterizations for the other local classes mb(1), . . . , vvc(1)in terms of extensions ofbackward modal logicthat offer additional types ofmodalities(viz., multimodal and graded modal logic).

Motivated by these results, the connection between distributed algorithms and

modal logicwas further investigated by Kuusisto in [Kuu13a] and [Kuu14]. The first paper lifts the constraint of locality required in [HJK+12,HJK+15], thereby allowing algorithms with arbitrary running times. Now, for local algorithms, it does not matter whether we impose a restriction on the amount of memory space used by eachnode, because in a constant number of rounds, anodecan only visit a constant number of different states. Therefore the local algorithms characterized by Hella et al. are implicitly finite-state machines. On the other hand, in thenonlocalcase considered by Kuusisto, space restrictions have to be made explicit. His papers focus on algorithms for the classsb, since results for that class can easily be adapted to the others. In [Kuu13a], particular attention is devoted to a category of such algorithms that act as finite-state semi-deciders; we shall refer to them asdistributed automata. The main result establishes a logical characterization ofdistributed automatain terms of a new recursive logic dubbedmodal substitution calculus. In the same vein, it is also shown that the infinite-state generalizations ofdistributed automatarecognize precisely thosegraph propertieswhose complement is definable by the conjunction of a possibly infinite number ofbackward modal formulas(called modal theory). Furthermore, it is proven that on finitegraphs,distributed automataare strictly more expressive than the least-fixpoint fragment of the backwardµ-calculus. This logic, which we shall refer to simply as thebackwardµ-fragment, extendsbackward modal logicwith a least fixpoint operator that may not be negated. It thus allows to express statements using least fixpoints, but unlike in the full backwardµ-calculus, greatest fixpoints are forbidden. Finally, the second paper [Kuu14] makes crucial use of the connection with logic to show that universally halting distributed automata are necessarily local if infinite graphs are allowed into the picture.

Closely related to the work mentioned above, the last decade has also seen active research indistributed decision [FF16], a field that aims to develop a counterpart of computational complexity theory for distributed computing. In that context, the

(19)

nodesof a given network have to collectively decide whether or not their network satisfies someglobal property. Everynodefirst computes a local answer, based on the information received from itsneighborsover several rounds of communication, and then all answers are aggregated to produce a global verdict. Typically, the network is considered to be in a valid state if it has been unanimously accepted by allnodes; in other words, the global answer is the logical conjunction of the local answers.

Just as in classical complexity theory, a common approach in distributed decision is to start with some base class of deterministic algorithms, and then extend it with additional features, such as nondeterminism and randomness. However, depending on the underlying model of distributed computing, these additional features can quickly lead to excessive expressive power. For instance, if we add unrestricted nondeterminism to the widely adopted local model,

The local model allows unbounded synchronous communication between Turing-complete proces-sors that are equipped with unique identifiers. Despite the name, al-gorithms in this model are not necessarily local.

then thenodescan simply guess a representation of the entire network and verify in one round that their guess was correct. Consequently, nondeterministic algorithms in the local model can already decide every Turing-decidablegraph propertyin a single round of communication (see, e.g., [FF16, § 4.1.1]). To make things more interesting, one therefore often imposes a restriction on the number of bits that eachnodecan nondeterministically choose; viewing nondeterminism as the ability to “guess and verify”, we refer to the bit strings guessed by thenodesascertificates. A typically chosen bound on the size of those certificates is logarithmic in the size of the network because this allows eachnodeto guess only a constant number of processor identifiers. In stark contrast to the unbounded case, where Turing-decidability is the only limit, there are natural decision problems that cannot be solved by any nondeterministic local algorithm whose certificates are logarithmically bounded. An example of such a problem is to verify whether a giventree is a minimum spanning tree, as has been shown by Korman and Kutten in [KK07]. Nevertheless, onconnected graphs, nondeterminism with logarithmic certificates provides enough power to decide every

property definableinemsolwithin a constant number of rounds, essentially by using nondeterministic bits to construct a spanning tree and simulate existentialset quantifiers. This observation has been made by Göös and Suomela in [GS11,GS16], based on the work of Schwentick and Barthelmann mentioned in the previous section. Once existential quantification has been introduced into the system, a natural follow-up is to complement it with universal quantification; for instance, in classical complexity theory, alternating the two types of quantifiers leads to the polynomial hierarchy, which generalizes the classes nptime and co-nptime. While not very interesting for the unrestricted local model with unbounded certificates (where nondeterminism already suffices to decide everything possible), this form of alterna-tion provides a genuine increase of power if we consider distributed algorithms that are oblivious to thenodeidentifiers. In [BDFO17], Balliu, D’Angelo, Fraigniaud and Olivetti showed that we require one alternation between universal and existential quantifiers in order to be able to decide every Turing-decidable property in the identifier-oblivious variant of the local model (with unbounded certificates); hence the corresponding alternation hierarchy collapses to its second level. On the other hand, the hierarchy of the standard local model with certificates of logarithmic size is much less well understood; in particular, it is still open whether or not that hierarchy is infinite. As a first step towards an answer, Feuilloley, Fraigniaud and Hirvonen showed in [FFH16] that if there is equality between the existential and uni-versal versions of a given level in the logarithmic hierarchy, then the entire hierarchy collapses to that level. Furthermore, they could identify a decision problem that lies

(20)

1.2 Contributions 7

outside of the hierarchy, which shows that even with the full power of alternation, algorithms whose certificates are logarithmically bounded remain weaker than their unrestricted counterparts.

1.2 Contributions

Obviously, developing a descriptive complexity theory for distributed computing is a highly ambitious project, of which the present work can only strive to be a small building block. As its title suggests, this thesis does not deal with the powerful models of computation that are usually considered in distributed computing. Instead, it takes an automata-theoretic approach and focuses on a rather weak model that has already been explored by Hella et al. and Kuusisto, namelydistributed automata. The main contributions are two new logical characterizations related to that model. The first covers a variant oflocal distributed automata, extended with a global acceptance condition and the ability to alternate between nondeterministic decisions of the individual processors and the creation of parallel computation branches. This kind of alternation constitutes a canonical generalization of nondeterminism, and is nowadays standard in automata theory. We show that the resulting alternat-ing local automata with global acceptanceareequivalenttomsolon finitedirected graphs. In spirit, they are similar to the alternation hierarchies considered in the distributed-decision community, even though their expressive power is much more restricted. They also share some similarities with Thomas’graphacceptors, as they use a combination of local conditions, checked by thenodesbased on their neigh-borhood, and global conditions, checked at the level of the entiregraph. However, both types of conditions are much simpler than in Thomas’ model, which allows us to considergraphsof unbounded degree. To a certain extent, theequivalence

withmsolcan be considered as a generalization tographsof the classical result of Büchi, Elgot and Trakhtenbrot, although the machines involved are by no means deterministic; whereas onwordsandtrees, alternation simply provides a more suc-cinct representation of deterministic automata, it turns out to be a crucial ingredient in our case. If we allow only nondeterminism, we get a model that is not closed under complementation, and is even strictly weaker thanemsol, but has a decidable emptiness problem. Interestingly, that model is still powerful enough to characterize precisely the regular languages when restricted towordsortrees. Hence, this work also contributes to the general observation, made inSection 1.1.1, that regularity becomes a moving target when lifted to the setting ofgraphs.

The second main contribution consists in a logical characterization of a fully deterministic class ofnonlocal automata. As mentioned inSection 1.1.2, Kuusisto has noticed thatdistributed automata, in their unrestricted form, are strictly more powerful than thebackwardµ-fragmenton finitegraphs. While it is straightforward to evaluate anyformulaof thebackwardµ-fragmentvia adistributed automaton, there also existautomatathat exploit the fact that anodecan determine if it receives the same information from all of itsneighborsat the exact same time. Such a behavior cannot be simulated in the backwardµ-fragment, and actually not even in the much more expressivemsol. However, since the argument relies solely on synchrony, it seems natural to ask whether removing this feature can lead to a distributed automaton model that has the same expressive power as thebackwardµ-fragment. To answer this question, we introduce several classes ofasynchronous automatathat

(21)

transfer the standard notion of asynchronous algorithm to the setting of finite-state machines. Basically, this means that we eliminate the global clock from the network, thus making it possible fornodesto operate at different speeds and for messages to be delayed for arbitrary amounts of time, or even be lost. From the syntactic point of view, anasynchronous automatonis the same as a synchronous one, but it has to satisfy an additional semantic condition: its acceptance behavior must be independent of any timing-related issues. Taking a closer look at theautomata

obtained by translatingformulasof thebackward µ-fragment, we can easily see that they are in fact asynchronous. Furthermore, theirstatediagrams are almost acyclic, except that thestatesare allowed to have self-loops; we call this property quasi-acyclic. As it turns out, the two properties put together are sufficient to give us the desired characterization:quasi-acyclic asynchronous automataareequivalentto thebackwardµ-fragmenton finitegraphs. Incidentally, this remains true even if we consider a seemingly more powerful variant ofasynchronous automata, where all messages are guaranteed to be delivered.

Another aspect ofdistributed automatainvestigated in this thesis are decision problems, and more specifically emptiness problems, where the task is to decide whether a givenautomaton acceptson at least one inputgraph. As all the equiv-alencesmentioned above are effective, we can immediately settle the decidability of theemptiness problemforlocal automata: it is decidable for the basic variant of Hella et al., but undecidable for the alternating extension that we shall consider. This is because the (finite) satisfiability problem is pspace-complete for (backward)

modal logicbut undecidable formsol. The problem is also decidable for our classes ofasynchronous automata, since (finite) satisfiability for the (backward)µ-calculus is exptime-complete. However, the corresponding question for unrestricted,nonlocal automatawas left open in [Kuu13a]. Here, we answer this question negatively for the general case and also consider it for three special cases. On the positive side, we obtain a logspace decision procedure for a class offorgetful automata, where the

nodessee the messages received from theirneighborsbut cannot remember their ownstate. When restricted to the appropriate families ofgraphs, theseforgetful au-tomataareequivalentto classical finitewordautomata, but strictly more expressive than finitetreeautomata. On the negative side, we show that the emptiness problem is already undecidable for two heavily restricted classes ofdistributed automata: the

quasi-acyclicones, and those that reject immediately if they receive more than one distinct message per round. For the latter class, we present a proof with an unusual twist, where a Turing machine is simulated by adistributed automatonin such a way that the roles of space and time are reversed between the two devices.

Finally, as a minor contribution, we investigate the problem of separatingquantifier

alternation hierarchies for several classes offormulasthat are based onmodal logic. Essentially, these classes are hybrids, obtained by adding theset quantifiersofmsol

to some variant ofmodal logic. They are motivated by the above characterizations oflocal distributed automatain terms of (backward)modal logic andmsol. The contribution is a toolbox of simple encoding techniques that allow to easily transfer to themodalsetting the separation results formsolestablished by Matz, Schweikardt and Thomas in [MT97,Sch97,MST02]. We thereby provide alternative proofs to similar findings previously reported by Kuusisto in [Kuu08,Kuu15].

(22)

1.3 Outline 9

1.3 Outline

The structure of this thesis is rather straightforward. All the notions that occur in several places are defined inChapter 2. In particular, there is a simple definition ofdistributed automatathat subsumes most of the variants we shall consider. The subsequent four chapters (i.e.,3to6) are independent of each other and thus can be read in any order. InChapter 3, we focus onlocal distributed automataand present thealternating variant with global acceptance, which is shown to beequivalent

tomsol. Chapter 4shifts the focus tononlocal automata; there we introduce the semantic notion ofasynchronyand show thatquasi-acyclic asynchronous automata

are captured by thebackwardµ-fragment.Nonlocal automataare also the subject ofChapter 5, where we present both positive and negative decidability results on theemptiness problemfor several restricted classes. Then, inChapter 6, we switch completely to logic and consider issues related toquantifieralternation hierarchies. Finally, some perspectives for future research are briefly outlined inChapter 7. Note to the reader of the electronic version. The PDF version of this document makes extensive use of hyperlinks. In addition to the cross-reference links inserted automatically by the standard LA

TEX packagehyperref, most of the notions defined within the document are linked to their point of definition. This new feature, which concerns both text and mathematical notation, is based on theknowledgepackage developed by Thomas Colcombet. Beware that there can be several links within a single symbolic expression; for instance, the expression_⟦bcΣmso

` (

→

ml_)⟧@dgcontains links to five different concepts:⟦. . .⟧, bc, Σmso

` ,

→

(23)

(24)

2

Preliminaries

This chapter introduces essential notation and terminology that will be recurring throughout this thesis. It is meant to be consulted for specific information rather than for consecutive reading. Concepts that are specific to a single chapter, will be introduced later, along with the topic.

2.1 Basic notation

We denote the empty set by∅, the set of Boolean values by2= {0,1}, the set of non-negative integers by_N= {0,1,2, . . .}, the set of positive integers by_N₊=_N∖ {0}, and the set of integers by_Z_{= {. . . , −}1,0,1, . . ._}.

Integer intervals of the form{i∈_Z∣m⩽i⩽n}, wherem,n∈_Zandm⩽n, will sometimes be denoted by[m∶n]. We may also use the shorthand[n]∶=[1∶n], and, by analogy with the Bourbaki notation for real intervals, we indicate that we exclude an endpoint by reversing the square bracket corresponding to that endpoint, e.g.,

]m∶n]∶=[m∶n]∖ {m}.

For any two setsSandT, the set of all functions fromStoT is denotedTS. This notation gives rise to two important special cases. First, we write2Sfor the power set ofS, since we can identify it with the set of all functions fromSto{0,1}. Second, givenk∈_N, we writeSk_∶=S[k]for the set of allk-tuples overS, since we can identify it with the set of functions from[k]toS. All of these notations have another special case in common: the set of binary strings of lengthk, denoted2k, can be interpreted as either the function space from[k] to2, or the power set of[k], or the set of

k-tuples over2. By the first interpretation, the individual letters of a string_xof lengthkwill be denotedx(1), . . . ,x(k). Furthermore, we write∣S∣for the cardinality ofSand∣x∣for the length ofx.

2.2 Symbols

Since logic plays an important role in this thesis, it also has an influence on how we present other concepts; in particular, our definition ofdirected graphsinSection 2.4

(25)

will refer to the notion of (abstract)symbol.

We shall not always make a sharp distinction betweenvariablesand (non-logical)

constants. Instead, there is simply a fixed supply ofsymbols, which can serve both asvariablesand asconstants. Hence, the terms “variable” and “constant” are just synonyms for “symbol”; we will use them whenever we want to clarify the intended role of asymbolwithin a given context.

The set_S₀contains ournode symbols, which withinformulaswill representnodes

ofstructures such asgraphs; among them, there is a special position symbol @. Moreover, for every integerk_⩾1, we let_S

kdenote the set ofk-ary relation symbols.

All of these sets are infinite and pairwise disjoint. If asymbollies in_S_k, fork⩾0, then we callkthearityof thatsymbol. We also denote the set of allsymbolsby_S, i.e., S∶= ⋃k⩾0Sk,

Scontains both

variablesand

constants.

and shall often refer to the unaryrelation symbolsin_S

1asset symbols.

Node symbols will always be represented by lower-case letters, and relation symbolsby upper-case ones, often decorated with subscripts. Typically, we usex,y,z fornode variablesor arbitrarynode symbols,X,Y,Zforset variablesor arbitrary

set symbols,P,Qforset constants, andR,Sforrelation constantsof higherarityor arbitrarysymbols. (SeeSection 2.6for some simple examples.)

2.3 Structures

Before we formally introducedirected graphsin the next section, we define the more general concept of a relationalstructure. Although the present thesis focuses mainly on variants ofdirected graphs, this top-down approach will allow us to specify the semantics of several types of logicalformulasin a unified framework, using a consistent notation. In particular, it will be apparent thatmodal logicsimply provides an alternative syntax for a certain fragment offirst-order logic(seeSection 2.5).

Letσbe any subset of_S. A (relational)structure_Gofsignature_σconsists of a nonempty set ofnodesVG(also called thedomainofG), anodexGofVGfor each

node symbolxinσ, and ak-ary relationRGonVGfor eachk-aryrelation symbolR

inσ. Here,xGandRGare calledG’sinterpretationsof thesymbolsxandR. We may also say thatGis astructureoverσ, or thatσis theunderlying signatureofG, and we denoteσbysig(G). In case theposition symbol @lies insig(G), we callGa

pointed structureand@Gthedistinguished nodeof_G.

A set ofstructureswill be referred to as astructure language. As is customary, we are only interested instructures up to isomorphism. That is, twostructures

over σ are considered to be equal if there is a bijection between their domains

that preserves theinterpretationsof allsymbolsinσ. Consequently, ourstructure languagescharacterize only properties that are invariant under isomorphism.

LetGbe astructureandαbe a map of the form_{S

1 ↦ I1, . . . ,Sn ↦In} that

assigns to eachsymbolS_i∈_S, fori∈[n], a suitableinterpretationI_iover thedomain

ofG. That is, ifS_i ∈ _S₀, thenI_i ∈VG, and ifS_i ∈_S_k, fork ⩾1, thenI_i ⊆ (VG)k. We use the notationG_[α_]to designate theα-extended variantofG, which is the

structureG′obtained fromGbyinterpretingeachsymbolS_iasI_i, while maintaining the otherinterpretationsprovided byG. More formally, lettingσ = {S1, . . . ,S_n}, we haveVG ′ = VG, sig₍G′_{) =} sig₍G_{) ∪}σ, SG ′ i =Ii fori ∈[n], andTG ′ =TG for

T ∈sig(G) ∖σ. Often, we do not want to give an explicit name to the assignmentα, in which case we may denoteG′byG[S1, . . . ,S_n↦I1, . . . ,I_n]. If theinterpretations

(26)

2.4 Different kinds of digraphs 13

variantofG. Furthermore, as we will often considerpointed variantsofstructures, we introduce the shorthandG[v]∶=G[@ ↦v]forv∈VG, and refer toG[v]as the v-pointed variantofG(i.e., thevariantofGwithdistinguished nodev).

2.4 Different kinds of digraphs

Thestructureswe are actually interested in are several variants ofdirected graphs; these arestructureswith finitedomainsand relations ofarityat most2. To facilitate lookup and comparison, we present them all in the same section. In the following definitions, letsandrbe non-negative integers.

Ans-bit labeled,r-relational directed graph, abbreviateddigraph, is a finite struc-tureGofsignature{P1, . . . ,P_s,R₁, . . . ,R_r}, where P1, . . . ,P_s areset symbols, and

R1, . . . ,R_rare binaryrelation symbols. The setsPG

1, . . . ,PGs, which we shall calllabeling sets, determine a (node)labeling

λG∶VG→2s that assigns a binary string of lengthsto eachnode. More precisely, we defineλGsuch that

λG(v)(i) = {

0 ifv_∉P

i,

1 otherwise,

for allv∈VGandi∈[s]. Given another mappingζ∶VG→2s ′

withs′∈_N, we shall

denote byG[ζ] Our bracket notation is

overloaded, but if one knows the type of_ζ, the ζ-relabeled variant_G_[_ζ_] of _Gshould be easy to distinguish from an α-extended variantG[α], as well as from a v-pointed variantG[v].

theζ-relabeled variantofG, i.e., thes′-bit labeleddigraphG′that is the same asG, except that itslabelingλG

′

is equal toζ.

It is often convenient to regard thelabelsof ans-bitlabeled digraphas the binary encodings of letters of some finite alphabetΣ. With respect to a given injective map

f∶Σ→2s, aΣ-labeled digraphis ans-bitlabeled digraphGsuch that for everynode

v∈VG, we haveλG₍v_{) =}f₍a_{) for some}a_∈Σ. Since we do not care about the specific encoding functionf, we will never mention it explicitly, and just callGaΣ-labeled,

r-relationaldigraph. The binary relationsRG

1, . . . ,RGr will be referred to asedge relations. Ifuvis an edgeinRG

i , thenuis called an incomingi-neighborofv, or simply an incoming

neighbor, andvis called anoutgoingi-neighborofu, or justoutgoing neighbor. We also say thatuandvareadjacent, and without further qualification, the termneighbor

refers to bothincomingandoutgoing neighbors. The (undirected)neighborhoodof a

nodeis the set of all of itsneighbors, and theincomingandoutgoingneighborhoods

are defined analogously. Anode withoutincoming neighbors is called asource, whereas anodewithoutoutgoing neighborsis called asink.

The class of alls-bitlabeled,r-relationaldigraphsis denoted bydgr

s. In case the

parameters ares=0andr=1, we may omit them and use the shorthanddg_∶=dg1

0.

We shall also drop the subscripts on thesymbols, and just writePorR, if there is only onesymbolof a givenarity. Furthermore, we denote bydgr

Σthe class of all Σ-labeled,r-relationaldigraphs.

As can be easily guessed from the previous definitions, apointed digraphis a

digraphin which somenodehas been marked by theposition symbol @, i.e., it is a

structureof the formG[@ ↦v], withG∈dgr

s andv∈VG. We write@dgrs for the

set of alls-bitlabeled,r-relationalpointed digraphs, and define@dg_∶=@dg1

0.

AdigraphGis called an (s-bitlabeled,r-relational)undirected graph, or simply

graph, if all of itsedge relationsare irreflexive and symmetric, i.e., if for allu,v∈VG

and i _∈ _[r_], it holds that uu _∉ RG

(27)

corresponding class is denoted bygraphr

s, and we may use the shorthandgraph∶=

graph1

0.

AdigraphGis (weakly)connectedif for every nonempty proper subsetWofVG, there exist twonodesu∈Wandv∈VG∖Wthat areadjacent.

Thenode labelingλGof aΣ-labeled digraphconstitutes a validcoloringofGif no twoadjacent nodesshare the samelabel, i.e., ifuv_∈RG

i impliesλ G

(u) ≠λG(v), for allu,v∈VGandi∈[r]. If∣Σ∣=k, such acoloringis called ak-coloringofG, and any

r-relationaldigraphfor which ak-coloringexists is said to bek-colorable. Note that, by definition, adigraphthat contains self-loops is notk-colorablefor anyk.

Adirected rooted tree, or ditree, is an (s-bitlabeled)r-relationaldigraphGthat has a distinctnodev, called theroot, such thatRG

i ∩RGj = ∅fori≠ j, and from

eachnodevinVG, there is exactly one way to reachv

by following the directed

edges_{in ⋃}

1⩽i⩽rRGi . Apointed ditreeis apointed digraphG[v], whereGis aditree

andvis itsroot. Moreover, a (pointed)r-relationalditree is calledorderedif for

1⩽i⩽r, everynodehas at most oneincomingi-neighborand everynodethat has anincoming(i+1)-neighboralso has anincomingi-neighbor. As a special case, an ordered1-relationalditreeis referred to as adirected path, ordipath. Accordingly, thedistinguished nodeof apointed dipathis the lastnode(the one with nooutgoing neighbor). The classes ofpointed dipathsandpointed ordered ditreescan be identified with thestructureson which classical word and tree automata are run. We denote them by@dipath

sand@oditreers, respectively.

We shall also consider an important subclass ofdg2

s whose members represent

rectangular labeled grids (also called pictures). In such a structureG, eachnode

is identified with a grid cell, and theedge relationsRG

1 andRG2 are interpreted as

the “vertical” and “horizontal” successor relations, respectively. The uniquenode

that has no predecessor at all is regarded as the “upper-left corner”, and all the usual terminology of matrices applies. Formally,Gis as-bit labeled gridif, for some

m,n⩾1, it is isomorphic to astructurewithdomain{1, . . . ,m} × {1, . . . ,n} andedge relations

RG₁ = {((i,j), (i+1,j)) ∣1⩽i<m,1⩽j⩽n},

RG₂ = {((i,j_{), (}i,j₊1_{)) ∣}1_⩽i_⩽m,1_⩽j_<n_}.

Ifs=0, we refer toGsimply as agrid. In alignment with the previous nomenclature, we letgridandgrid_sdenote the classes ofgridsands-bit labeled grids.

Adigraph languageis astructure languagethat consist ofdigraphswith a fixed number oflabeling setsandedge relations, i.e., a subset ofdgr

s, for somes,r∈N+.

The notion is defined analogously for all the other classes ofstructuresintroduced above. In particular, apointed-digraph languageis a subset of@dgr

s.

2.5 The considered logics

As we shall contemplate both classical logic and several variants ofmodal logic, we introduce them all in a common framework. First we define the syntax and semantics of a generalized language, and then we specify which particular syntactic fragments we are interested in. Some examples will follow inSection 2.6.

Table 2.1shows howformulasare built up, and what they mean. Furthermore, it indicates how to obtain the setfree₍ϕ_{) of}symbolsthat occurfreelyin a given

(28)

2.5 The considered logics 15

Syntax Free symbols Semantics

Formula_ψ Symbol setfree₍_ψ₎ Necessary and sufficient condition for_G_⊧_ψ

x {@,_x_} @G₌_xG (x≐y) {x,y} xG =yG X {@,_X_} @G_∈_XG X(x) {x,X} xG ∈XG R(x0, . . . ,xk) {x0, . . . ,xk,R} (xG0, . . . ,x G k) ∈R G ¬ϕ free(ϕ) not G⊧ϕ (ϕ1∨ϕ2) free(ϕ1) ∪free(ϕ2) G⊧ϕ1 or G⊧ϕ2 R₍_ϕ₁, . . . ,ϕ_k) {@,R_{} ∪ ⋃} 1⩽i⩽k

free(ϕi) For somev₁, . . ,v_k∈VGsuch that(@G,v₁, . . ,v_k) ∈RG, we haveG[@ ↦vi] ⊧ϕifor eachi∈ {1, . . ,k}.

R₍_ϕ₁, . . . ,ϕ_k) same as above As above, except for the condition (vk, . . . ,v₁,@G) ∈RG.

● ϕ free(ϕ) ∖ {@} G[@ ↦v] ⊧ϕfor somev∈VG

∃xϕ free(ϕ) ∖ {x} G[x↦v] ⊧ϕfor somev∈VG

∃Xϕ free(ϕ) ∖ {X} G[X↦W] ⊧ϕfor someW⊆VG

Here, _x,_x₀, . . . ,_x_k,_y_∈_S₀, _X_∈_S₁, _R_∈_S_k

+1, andϕ,ϕ1, . . . ,ϕkareformulas, fork⩾1.

Table 2.1. Syntax and semantics of the considered logics.

Class of formulas Generating grammar

fol First-order _ϕ∶∶= (x≐y) ∣X(x)∣R(x0, . . . ,xk)∣¬ϕ∣ (ϕ1∨ϕ2) ∣∃xϕ

emsol Existentialmsol ϕ∶∶=ψ∣∃Xϕ, whereψ∈fol.

Equivalently,emsol∶=Σmso

1 (fol); seeSection 6.1.

msol Monadic ϕ∶∶= (x≐y) ∣X(x)∣R(x0, . . . ,x_k)∣¬ϕ∣ (ϕ1∨ϕ2) ∣∃xϕ∣∃Xϕ

second-order Equivalently,msol∶=mso(fol). → ml Modal _ϕ∶∶=x∣X∣¬ϕ∣ (ϕ1∨ϕ2) ∣ R (ϕ1, . . . ,ϕk) ← ml Backward modal ϕ∶∶=x∣X∣¬ϕ∣ (ϕ1∨ϕ2) ∣ R (ϕ1, . . . ,ϕ_k) ↔ ml Bidirectional modal ϕ∶∶=x∣X∣¬ϕ∣ (ϕ1∨ϕ2) ∣ R (ϕ1, . . . ,ϕ_k) ∣ R ₍_ϕ₁, . . . ,ϕ_k) → ml_g Modal with global modalities ϕ∶∶=x∣X∣¬ϕ∣ (ϕ1∨ϕ2) ∣ R (ϕ1, . . . ,ϕk) ∣ ● ϕ ← mlg, ↔

mlg Analogous to the preceding grammars.

mso(Φ) Φextended with

set quantifiers

Same grammar asΦwith the additional choice “∣∃Xϕ”.

Here, _x,_x₀, . . . ,_x_k,_y_∈_S₀, _X_∈_S₁, _R_∈_S_k

+1, fork⩾1, andΦ∈ {

→

ml,ml←, . . . ,ml↔_g,fol_}.

(29)

formulaϕ, i.e., outside the scope of a binding operator. Iffree(ϕ) ⊆σ, we say thatϕ is asentenceoverσ. Sometimes, when the notions of “variable” and “constant” are clear from context, we also use the notationϕ₍x

1, . . . ,xm,X1, . . . ,Xn)to indicate that

at most thevariablesgiven in brackets occurfreelyinϕ, i.e., that no othervariables

thanx₁, . . . ,x_m,X₁, . . . ,X_nlie infree(ϕ). The relation⊧defined inTable 2.1specifies in which cases astructureGsatisfiesϕ, writtenG_⊧ϕ, assuming thatϕis asentence

oversig(G). Otherwise, we stipulate thatG⊭ϕ.

Of particular interest for this thesis are thoseformulasin which thenode symbol @

is considered to befree, although it might not occur explicitly. They are evaluated on apointed structureGfrom the perspective of thenode @G. Atomicformulas

of the formx orX, with x ∈ _S₀ andX ∈ _S₁, aresatisfiedif@G is labeled by the correspondingsymbol. Using the operator R, which is called theR-diamond, we can remap thesymbol @through existential quantification over thenodesinGthat are reachable from@Gthrough the relationRG. If we want to do the same with respect to the inverse relation ofRG, we can use thebackwardR-diamond R. In addition, there is also theglobal diamond ● (unfortunately often called “universal modality”), which ranges over allnodesofG. It can be considered as thediamond operator

corresponding to the relationVG_×VG, i.e., theedge relationof the completedigraph

overVG. To facilitate certain descriptions, we shall sometimes treat R and ● as special cases of R, assuming that they are implicitly associated with the reserved

relation symbolsR−1 and●, respectively. Thesesymbolsdo not belong to_S, and therefore cannot beinterpretedby anystructure.

Allowing a bit of syntactic sugar, we will make liberal use of the remaining operators of predicate logic, i.e.,_∧,_→,_↔,_∀, and we may leave out some parentheses, assuming that∨and∧take precedence over→and↔. Furthermore, we define the abbreviations

⊺∶=@, _∶=_¬@, and

R(ϕ1, . . . ,ϕ_k) ∶= ¬R(¬ϕ1, . . . ,¬ϕk).

Note that it makes sense to define⊺(“true”) as@, since by definition, the atomic

formula @is alwayssatisfiedat the point of evaluation. Also, the second line remains applicable if one substitutesR−1 or●forR. The resulting operators R, R and ●

provide universal quantification and are calledboxes(using the same attributes as fordiamonds). Diamonds andboxesare collectively referred to asmodalities or

modal operators. In case we restrict ourselves tostructuresthat only have a single relation, we may omit therelation symbolR, and just use emptymodalitiessuch as . Similarly, if therelation symbolsinvolved are indexed, likeR₁, . . . ,R_r, we associate them withmodalitiesof the form i , for1⩽i⩽r.

Let us now turn to the particular classes offormulas considered in this thesis, which are specified inTable 2.2. The languages offirst-order logic(fol),existential monadic second-order logic(emsol), andmonadic second-order logic(msol) are defined in the usual way. When evaluated on somestructureG, their atomicformulasallow to comparenodesassigned tonode symbolsinsig(G) with respect to the equality relation and any other relation assigned to arelation symbolinsig(G). Infol, we can assign newinterpretationstonode symbolsby means of existential and universal

quantification over nodes. In emsol, we may additionally reinterpret set symbols

using existentialquantifiers over setsofnodes, and inmsol, we can also use the corresponding universalquantifiers.

(30)

2.6 Example formulas 17

The remaining classes offormulascan all be qualified as modal languages, insofar as they includemodal operatorsinstead of the classicalfirst-order quantifiers. By performing this change of paradigm, we lose our “bird’s-eye view” of thestructureG, and now see it from the local point of view of thenode @G. (For this,Gobviously has to bepointed.) In basicmodal logic(ml→), anode“sees” only itsoutgoing neighbors, and thus our domain of quantification is restricted to thoseneighbors. Furthermore, theposition symbol @is the onlynode symbolwhoseinterpretationcan be changed by amodal operator.Backward modal logic(ml←) is the variant ofml→ where anode

“sees” itsincoming neighborsinstead of itsoutgoing neighbors, whereasbidirectional modal logic(ml↔) is the combination where anode“sees” bothincomingandoutgoing neighbors. We will also look atmodal logic with global modalities(ml→_g), where we regain the possibility to quantify over the entiredomainof thestructure, but are still confined to remapping only theposition symbol @. The backward and bidirectional variantsml←gand

↔

mlgare defined analogously. Finally, we also consider crossover

versions ofmodal logicthat are enriched with theset quantifiersofmsol. Given a class offormulasΦ, we denote bymso(Φ) the corresponding enriched class. For instance, theformulasofmso(ml→) are generated by the grammar

ϕ∶∶=x∣X∣¬ϕ∣ (ϕ1∨ϕ2) ∣ R(ϕ1, . . . ,ϕ_k) ∣∃_Xϕ,

wherex∈_S₀, X∈_S₁, andR∈_S_k+1. Note that by this notation,msol=mso(fol). For any class offormulasΦ, we shall refer to its members asΦ-formulas. Given a

Φ-formulaϕ, a class ofstructuresC (e.g.,dg), and astructureG, we use the semantic bracket notations⟦ϕ⟧_C and⟦ϕ⟧_G to denote thestructure language defined byϕ overC, and the set ofnodesofGat whichϕholds. More formally,

⟦ϕ⟧_C ∶= {G∈C ∣G⊧ϕ}, and

⟦ϕ⟧_G∶= {v∈VG∣G[@ ↦v] ⊧ϕ}. Furthermore,_⟦Φ_⟧

Cdenotes the family ofstructure languagesthat aredefinableinΦ (orΦ-definable) overC, i.e.,

⟦Φ⟧_C∶= {⟦ϕ⟧_C∣ϕ∈Φ}.

IfC is equal to the set of allstructures, then we do not have to specify it explicitly as a subscript; that is, we may simply write⟦ϕ⟧and⟦Φ⟧instead of⟦ϕ⟧_Cand⟦Φ⟧_C. Similarly, we use

[ϕ]_C∶= {ψ∣⟦ψ⟧_C=⟦ϕ⟧_C}

for theequivalenceclass ofϕoverC, and

[Φ]_C∶= ⋃

ϕ∈Φ

[ϕ]_C

for the set of allformulasthat areequivalentoverC to someformulainΦ. Again, we may drop the subscript if we do not want to restrict to a particular class ofstructures.

2.6 Example formulas

In order to illustrate the syntax introduced in the previous section, we now look at two simple examples.

(31)

The first is a great classic that is often used to show how a widely knowngraph propertycan be expressed inmsolwithout too much effort.

Example 2.1 (3-Colorability).

▸

The followingemsol-formula definesthelanguageof3-colorable digraphsoverdg.

ϕcolor 3 ∶=∃X1,_X₂,_X₃(∀_x( (X₁(x) ∨X₂(x) ∨X₃(x))∧ ¬(X1(x) ∧X2(x))∧ ¬(X1(x) ∧X3(x))∧ ¬(X2(x) ∧X3(x)) )∧ ∀_x,_y(R(x,y) → ¬(X₁(x) ∧X₁(y))∧ ¬(X₂(x) ∧X₂(y))∧ ¬(X3(x) ∧X3(y)) ) )

The existentially quantifiedset variablesX

1,X2,X3∈S1represent the three possible

colors. In the first four lines, we specify that the sets assigned to thesevariablesform a partition of the set ofnodes(possibly with empty components). The remaining three lines constitute the actual definition of a validcoloring: no twoadjacent nodes

share the same color, which means thatadjacent nodesare in different sets.

_◂

Our second example is equally simple, but less glamorous because it illustrates a technical issue that will concern us in Chapter 6, where we shall work with

mso(ml→g) and some variants thereof. As we do not allowfirst-order quantificationin modal logicwithset quantifiers, some properties that seem very natural infol(and thusmsol) become rather cumbersome to express. Nevertheless, translation from

foltomso(ml→g) is always possible because we can simulatefirst-order quantifiers

byset quantifiersrelativized to singletons, which, by extension, also entails the

equivalenceofmsolandmso₍ml→_g_).Example 2.2presents the basic construction that allows us to do this. We will refer to it several times inChapter 6.

Example 2.2 (Uniqueness).

▸

Consider the followingformulaschema, whereX_∈_S

1, R∈S2, andϕcan be any

↔

mlg-formula:

see1_R(ϕ) ∶= Rϕ ∧ ∀_X(R(ϕ∧X)→ R(ϕ→X)).

When evaluated on apointed structureGwhosesignatureincludes{@,R} ∪free(ϕ), theformula see1_R(ϕ) states that there is exactly onenodev∈VGreachable from

@Gthrough anRG-edge, such thatϕissatisfiedatv(i.e., by thestructureG[@ ↦v]). In the context of1-relationaldigraphs, we may use the shorthandsee1(ϕ) to invoke this schema. Using the same construction withglobal modalities, we also define

tot1₍ϕ_{) ∶=}see1 ●(ϕ),

which states that there is precisely onenodein the entirestructureGat whichϕis

satisfied. Here,Gdoes not necessarily have to bepointed, and, of course,sig(G) does not contain_●(since it is thesymbolreserved for the total symmetric relation).

_◂

(32)

2.7 Distributed automata 19

Anticipating the notation ofSection 6.1, theformulasobtained by the construction inExample 2.2can be classified as[Πmso

1 (Φ)]-formulas, whereΦ∈ {

→

ml,ml↔,ml→_g,ml↔_g} depends on the specificmodalitiesthat occur inϕ.

2.7 Distributed automata

We conclude this preliminary chapter by introducing our primary objects of inter-est. Simply put, adistributed automatonis a deterministic finite-state machine_A that reads sets ofstatesinstead of the usual alphabetic symbols. To runAon a

1-relationaldigraphG, we place a separate copy of themachineon everynodev

ofG,initializeit to astatethat may depend onv’slabelλG₍v_{), and then let all the} nodescommunicate in an infinite sequence of synchronous rounds. In every round, eachnodecomputes its nextstateas afunctionof its own currentstateand the set of

statesof itsincoming neighbors. Intuitively,nodevbroadcasts its currentstateqto everyoutgoing neighbor, while at the same time collecting thestatesreceived from itsincoming neighborsinto a setS; the successorstateofqis then computed as a

functionofqandS. SinceSis a set (as opposed to a multiset or a vector),vcannot distinguish between twoincoming neighborsthat share the samestate. Now, acting as a semi-decider, themachineatnodevacceptsprecisely if it visits anaccepting stateat some point in time. Either way, allmachinesof the network keep running and communicating forever. This is because even if anodehas alreadyaccepted, it may still obtain new information that affects theacceptance behaviorof itsoutgoing neighbors.

Let us now define the notion ofdistributed automatonmore formally, and gener-alize it todigraphswith an arbitrary number ofedge relations.

Definition 2.3 (Distributed automaton).

▸

A (deterministic,nonlocal)distributed automaton(da) over_Σ-labeled,_r-relational

digraphs is a tupleA = (Q,δ₀,δ,F), whereQ is a finite nonempty set of states,

δ0∶Σ→Qis aninitialization function,δ∶Q× (2Q)r→Qis atransition function, and

F⊆Qis a set ofaccepting states.

_◂

LetGbe aΣ-labeled,r-relationaldigraph. TherunofAonGis an infinite sequence

ρ = (ρ0,ρ₁,ρ₂, . . .) of mapsρt∶VG →Q, calledconfigurations, which are defined inductively as follows, fort_∈_Nandv_∈VG:

ρ₀(v) =δ₀(λG(v)) and ρ

t+1(v) =δ(ρt(v), ({ρt(u) ∣uv∈RGi })₁_⩽_i_⩽_r).

For_v_∈_VG, the automaton_Aacceptsthepointed digraph_G_[_v_]if_vvisits anaccepting stateat some point in therunρofAonG, i.e., if there existst∈_Nsuch thatρ_t(v) ∈F. Thepointed-digraph languageofA, orpointed-digraph languagerecognized byA, is the set of allpointed digraphsthat areacceptedbyA. We denote thislanguage

by⟦A⟧@dgr

Σ

, in analogy to our notation for logicalformulas. Similarly, given a class ofautomataA, we write⟦A⟧@dgr

Σ

for the class ofpointed-digraph languagesover

@dgr

Σthat arerecognizedby some member ofA; we call themA-recognizable.

As usual, two devices (i.e.,automataorformulas) areequivalentif they specify (i.e.,recognizeordefine) the samelanguage.

In distributed computing, one often considers algorithms that run in a constant number of synchronous rounds. They are known as local algorithms (see, e.g.,

Distributed Automata and Logic

HAL Id: tel-01827435

https://hal.archives-ouvertes.fr/tel-01827435

Fabian Reiter

To cite this version:

δ

∶

Q

×

2

Q

→

Q

Distributed Automata and Logic

Fabian Reiter

Distributed Automata and Logic

Fabian Reiter

Contents

Abstract

Résumé

Acknowledgments

1

Introduction

1.1 Background

1.2 Contributions

1.3 Outline

2

Preliminaries

2.1 Basic notation

2.2 Symbols

2.3 Structures

2.4 Different kinds of digraphs

2.5 The considered logics

2.6 Example formulas

▸

◂

▸

◂

2.7 Distributed automata

▸

◂

_◂

_◂

_◂