Monadic Second-order Research Articles

Maintaining CMSO 2 properties on dynamic structures with bounded feedback vertex number

Let φ be a sentence of \(\mathsf {CMSO}_2 \) (monadic second-order logic with quantification over edge subsets and counting modular predicates) over the signature of graphs. We present a dynamic data structure that for a given graph G that is updated by edge insertions and edge deletions, maintains whether φ is satisfied in G . The data structure is required to correctly report the outcome only when the feedback vertex number of G does not exceed a fixed constant k , otherwise it reports that the feedback vertex number is too large. With this assumption, we guarantee amortized update time \(\mathcal {O}_{\varphi,k}{(\log n)} \) . If we additionally assume that the feedback vertex number of G never exceeds k , this update time guarantee is worst-case. By combining this result with a classic theorem of Erdős and Pósa, we give a fully dynamic data structure that maintains whether a graph contains a packing of k vertex-disjoint cycles with amortized update time \(\mathcal {O}_{k}{(\log n)} \) . Our data structure also works in a larger generality of relational structures over binary signatures.

Streaming Enumeration on Nested Documents

Some of the most relevant document schemas used online, such as XML and JSON, have a nested format. In the past decade, the task of extracting data from nested documents over streams has become especially relevant. We focus on the streaming evaluation of queries with outputs of varied sizes over nested documents. We model queries of this kind as Visibly Pushdown Annotators (VPAnn), a computational model that extends visibly pushdown automata with outputs and has the same expressive power as monadic second-order logic over nested documents. Since processing a document through a VPAnn can generate a massive number of results, we are interested in reading the input in a streaming fashion and enumerating the outputs one after another as efficiently as possible, namely, with constant delay. This article presents an algorithm that enumerates these elements with constant delay after processing the document stream in a single pass. Furthermore, we show that this algorithm is worst-case optimal in terms of update-time per symbol and memory usage.

Decidability in geometric grid classes of permutations

We prove that the basis and the generating function of a geometric grid class of permutations G e o m ( M ) \mathrm {Geom}(M) are computable from the matrix M M , as well as some variations on this result. Our main tool is monadic second-order logic on permutations and words.

Fine-grained Meta-Theorems for Vertex Integrity

Vertex Integrity is a graph measure which sits squarely between two more well-studied notions, namely vertex cover and tree-depth, and that has recently gained attention as a structural graph parameter. In this paper we investigate the algorithmic trade-offs involved with this parameter from the point of view of algorithmic meta-theorems for First-Order (FO) and Monadic Second Order (MSO) logic. Our positive results are the following: (i) given a graph $G$ of vertex integrity $k$ and an FO formula $\phi$ with $q$ quantifiers, deciding if $G$ satisfies $\phi$ can be done in time $2^{O(k^2q+q\log q)}+n^{O(1)}$; (ii) for MSO formulas with $q$ quantifiers, the same can be done in time $2^{2^{O(k^2+kq)}}+n^{O(1)}$. Both results are obtained using kernelization arguments, which pre-process the input to sizes $2^{O(k^2)}q$ and $2^{O(k^2+kq)}$ respectively. The complexities of our meta-theorems are significantly better than the corresponding meta-theorems for tree-depth, which involve towers of exponentials. However, they are worse than the roughly $2^{O(kq)}$ and $2^{2^{O(k+q)}}$ complexities known for corresponding meta-theorems for vertex cover. To explain this deterioration we present two formula constructions which lead to fine-grained complexity lower bounds and establish that the dependence of our meta-theorems on $k$ is the best possible. More precisely, we show that it is not possible to decide FO formulas with $q$ quantifiers in time $2^{o(k^2q)}$, and that there exists a constant-size MSO formula which cannot be decided in time $2^{2^{o(k^2)}}$, both under the ETH. Hence, the quadratic blow-up in the dependence on $k$ is unavoidable and vertex integrity has a complexity for FO and MSO logic which is truly intermediate between vertex cover and tree-depth.

Tractable Circuits in Database Theory

This work reviews how database theory uses tractable circuit classes from knowledge compilation. We present relevant query evaluation tasks, and notions of tractable circuits. We then show how these tractable circuits can be used to address database tasks. We first focus on Boolean provenance and its applications for aggregation tasks, in particular probabilistic query evaluation. We study these for Monadic Second Order (MSO) queries on trees, and for safe Conjunctive Queries (CQs) and Union of Conjunctive Queries (UCQs). We also study circuit representations of query answers, and their applications to enumeration tasks: both in the Boolean setting (for MSO) and the multivalued setting (for CQs and UCQs).

Numerical expressive power of logical languages with cardinality comparison

Abstract In this paper, we investigate the numerical expressive power of various logical languages, encompassing fragments of Presburger Arithmetic (PbA), monadic second-order logic with counting with respect to finite domains (MSO$^{\phi }(\#)$) and shallow second-order graded modal logic with counting with respect to image-finite frames (SOGML$^{\textsf{s},\phi }$(#)). We show that in their respective existential fragments, the $1$-free fragment of PbA, the =-free fragment of MSO$^{\phi }(\#)$ and the graded modality-free fragment of SOGML$^{\textsf{s},\phi }$(#) possess equivalent numerical expressive power, specifically defining strongly semilinear sets. When adding universal quantifiers or adding $1$, = and graded modality to these three languages, the resulting definable sets become semilinear sets.

Grouped domination parameterized by vertex cover, twin cover, and beyond

A dominating set S of graph G is called an r-grouped dominating set if S can be partitioned into S1,S2,…,Sk such that the size of each unit Si is r and the subgraph of G induced by Si is connected. The concept of r-grouped dominating sets generalizes several well-studied variants of dominating sets with requirements for connected component sizes, such as the ordinary dominating sets (r=1), paired dominating sets (r=2), and connected dominating sets (r is arbitrary and k=1). In this paper, we investigate the computational complexity of r-Grouped Dominating Set, which is the problem of deciding whether a given graph has an r-grouped dominating set with at most k units. For general r, r-Grouped Dominating Set is hard to solve in various senses because the hardness of the connected dominating set is inherited. We thus focus on the case in which r is a constant or a parameter, but we see that r-Grouped Dominating Set for every fixed r>0 is still hard to solve. From the observations about the hardness, we consider the parameterized complexity concerning well-studied graph structural parameters. We first see that r-Grouped Dominating Set is fixed-parameter tractable for r and treewidth, which is derived from the fact that the condition of r-grouped domination for a constant r can be represented as monadic second-order logic (MSO2). This fixed-parameter tractability is good news, but the running time is not practical. We then design an O⁎(min⁡{(2τ(r+1))τ,(2τ)2τ})-time algorithm for general r≥2, where τ is the twin cover number, which is a parameter between vertex cover number and clique-width. For paired dominating set and trio dominating set, i.e., r∈{2,3}, we can speed up the algorithm, whose running time becomes O⁎((r+1)τ). We further argue the relationship between FPT results and graph parameters, which draws the parameterized complexity landscape of r-Grouped Dominating Set.

On Model-Checking Higher-Order Effectful Programs

Model-checking is one of the most powerful techniques for verifying systems and programs, which since the pioneering results by Knapik et al., Ong, and Kobayashi, is known to be applicable to functional programs with higher-order types against properties expressed by formulas of monadic second-order logic. What happens when the program in question, in addition to higher-order functions, also exhibits algebraic effects such as probabilistic choice or global store? The results in the literature range from those, mostly positive, about nondeterministic effects, to those about probabilistic effects, in the presence of which even mere reachability becomes undecidable. This work takes a fresh and general look at the problem, first of all showing that there is an elegant and natural way of viewing higher-order programs producing algebraic effects as ordinary higher-order recursion schemes. We then move on to consider effect handlers, showing that in their presence the model checking problem is bound to be undecidable in the general case, while it stays decidable when handlers have a simple syntactic form, still sufficient to capture so-called generic effects. Along the way, we hint at how a general specification language could look like, this way justifying some of the results in the literature, and deriving new ones.

A Nivat Theorem for Weighted Alternating Automata over Commutative Semirings

This paper connects the classes of weighted alternating finite automata (WAFA), weighted finite tree automata (WFTA), and polynomial automata (PA). First, we investigate the use of trees in the run semantics for weighted alternating automata and prove that the behavior of a weighted alternating automaton can be characterized as the composition of the behavior of a weighted finite tree automaton and a specific tree homomorphism, if weights are taken from a commutative semiring. Based on this, we give a Nivat-like characterization for weighted alternating automata. Moreover, we show that the class of series recognized by weighted alternating automata is closed under inverses of homomorphisms, but not under homomorphisms. Additionally, we give a logical characterization of weighted alternating automata, which uses weighted MSO logic for trees. Finally, we investigate the strong connection between weighted alternating automata and polynomial automata. We prove: A weighted language is recognized by a weighted alternating automaton iff its reversal in recognized by a polynomial automaton. Using the corresponding result for polynomial automata, we are able to prove that the ZERONESS problem for weighted alternating automata with weights taken from the rational numbers decidable.

Tree-Based Generation of Restricted Graph Languages

Order-preserving DAG grammars (OPDGs) is a formalism for representing languages of structurally restricted graphs. As demonstrated in [17], they are sufficiently expressive to model abstract meaning representations in natural language processing, a graph-based form of semantic representation in which nodes encode objects and edges relations. At the same time, they can be parsed in [Formula: see text], where [Formula: see text] and [Formula: see text] are the sizes of the grammar and the input graph, respectively. In this work, we provide an initial algebra semantic for OPDGs, which allows us to view them as regular tree grammars under an equivalence theory. This makes it possible to transfer results from the field of formal tree languages to the domain of OPDGs, both in the unweighted and the weighted case. In particular, we show that deterministic OPDGs can be minimised efficiently, and that they are learnable under the “minimal adequeate teacher” paradigm, that is, by querying an oracle for equivalence between languages, and membership of individual graphs. To conclude, we demonstrate that the languages generated by OPDGs are definable in monadic second-order logic.

A Monadic Second-Order Version of Tarski’s Geometry of Solids

In this paper, we are concerned with the development of a general set theory using the single axiom version of Leśniewski’s mereology. The specification of mereology, and further of Tarski’s geometry of solids will rely on the Calculus of Inductive Constructions (CIC). In the first part, we provide a specification of Leśniewski’s mereology as a model for an atomless Boolean algebra using Clay’s ideas. In the second part, we interpret Leśniewski’s mereology in monadic second-order logic using names and develop a full version of mereology referred to as CIC-based Monadic Mereology (λ-MM) allowing an expressive theory while involving only two axioms. In the third part, we propose a modeling of Tarski’s solid geometry relying on λ-MM. It is intended to serve as a basis for spatial reasoning. All parts have been proved using a translation in type theory.

A Model Checker for Operator Precedence Languages

The problem of extending model checking from finite state machines to procedural programs has fostered much research toward the definition of temporal logics for reasoning on context-free structures. The most notable of such results are temporal logics on Nested Words, such as CaRet and NWTL. Recently, Precedence Oriented Temporal Logic (POTL) has been introduced to specify and prove properties of programs coded trough an Operator Precedence Language (OPL). POTL is complete w.r.t. the FO restriction of the MSO logic previously defined as a logic fully equivalent to OPL. POTL increases NWTL’s expressive power in a perfectly parallel way as OPLs are more powerful that nested words. In this article, we produce a model checker, named POMC, for OPL programs to prove properties expressed in POTL. To the best of our knowledge, POMC is the first implemented and openly available model checker for proving tree-structured properties of recursive procedural programs. We also report on the experimental evaluation we performed on POMC on a nontrivial benchmark.

First-order Logic with Connectivity Operators

First-order logic (FO) can express many algorithmic problems on graphs, such as the independent set and dominating set problem parameterized by solution size. However, FO cannot express the very simple algorithmic question whether two vertices are connected. We enrich FO with connectivity predicates that are tailored to express algorithmic graph problems that are commonly studied in parameterized algorithmics. By adding the atomic predicates conn k ( x,y,z_1,..., z k ) that hold true in a graph if there exists a path between (the valuations of) x and y after (the valuations of) z 1 ,..., z k have been deleted, we obtain separator logic FO + conn. We show that separator logic can express many interesting problems, such as the feedback vertex set problem and elimination distance problems to first-order definable classes. Denote by FO + conn k the fragment of separator logic that is restricted to connectivity predicates with at most k + 2 variables (that is, at most k deletions), we show that FO + conn k + 1 is strictly more expressive than FO + conn k for all k ≥ 0 . We then study the limitations of separator logic and prove that it cannot express planarity, and, in particular, not the disjoint paths problem. We obtain the stronger disjoint-paths logic FO + DP by adding the atomic predicates disjoint-paths k [( x 1 , y 1 ),..., ( x k , y k ) that evaluate to true if there are internally vertex-disjoint paths between (the valuations of) x i and y i for all 1 ≤ i ≤ k . Disjoint-paths logic can express the disjoint paths problem, the problem of (topological) minor containment, the problem of hitting (topological) minors, and many more. Again, we show that the fragments FO + DP k that use predicates for at most k disjoint paths form a strict hierarchy of expressiveness. Finally, we compare the expressive power of the new logics with that of transitive-closure logics and monadic second-order logic.

Tree Automata and Pigeonhole Classes of Matroids: II

Let $\psi$ be a sentence in the counting monadic second-order logic of matroids and let F be a finite field. Hlineny's Theorem says that we can test whether F-representable matroids satisfy $\psi$ using an algorithm that is fixed-parameter tractable with respect to branch-width. In a previous paper we proved there is a similar fixed-parameter tractable algorithm that can test the members of any efficiently pigeonhole class. In this sequel we apply results from the first paper and thereby extend Hlineny's Theorem to the classes of fundamental transversal matroids, lattice path matroids, bicircular matroids, and H-gain-graphic matroids, when H is a finite group. As a consequence, we can obtain a new proof of Courcelle's Theorem.

Twin-distance-hereditary digraphs

Distance-hereditary graphs are in important graph class in graph theory, as they are well-placed in the graph class hierarchy and permit many algorithmic results. We investigate structural and algorithmic advantages of a directed version of this well-researched graph class. Since the previously defined distance-hereditary digraphs do not permit a recursive structure, we define directed twin-distance-hereditary graphs, which can be constructed by several twin and pendant vertex operations analogously to undirected distance-hereditary graphs and which still preserves the distance hereditary property. We give a characterization by forbidden induced subdigraphs and place the class in a hierarchy comparing it to related classes. We further show algorithmic advantages concerning directed width parameters, directed graph coloring and some other well-known digraph problems which are NP-hard in general, but computable in polynomial or even linear time on twin-distance-hereditary digraphs. This includes computability of directed path-width and tree-width in linear time and the directed chromatic number in polynomial time. From our result that directed twin-distance-hereditary graphs have directed clique-width at most 3 it follows by Courcelle's theorem on directed clique-width that we can compute every graph problem describable in monadic second-order logic on quantification over vertices and vertex sets as well as some further problems like Hamiltonian Path/Cycle in polynomial time.

Uniform Restricted Chase Termination

The chase procedure is a fundamental algorithmic tool in database theory with a variety of applications. A central problem concerning the chase procedure is uniform (a.k.a. all-instances) chase termination: for a given set of tuple-generating dependencies (TGDs), is it the case that the chase terminates for every input database? In view of the fact that this problem is, in general, undecidable, it is natural to ask whether known well-behaved classes of TGDs ensure decidability. We focus on the main paradigms that led to robust TGD-based formalisms, namely guardedness and stickiness, that have been introduced in the context of knowledge-enriched databases. Although uniform chase termination is well understood for the oblivious version of the chase (2EXPTIME-complete for guarded, and PSPACE-complete for sticky TGDs), the more subtle case of the restricted (a.k.a. the standard) chase is rather unexplored. We show that uniform restricted chase termination under guarded single-head TGDs and sticky single-head TGDs is decidable in elementary time. In the case of guardedness, we provide a reduction to the satisfiability problem of monadic second-order logic over infinite trees of bounded degree, while for stickiness we provide a reduction to the emptiness problem of deterministic Büchi automata. Those reductions build on a series of technical results of independent interest related to the notion of fairness of the restricted chase, and the existence of critical databases that characterize nontermination of the restricted chase via databases of a certain form.

Faster Property Testers in a Variation of the Bounded Degree Model

Property testing algorithms are highly efficient algorithms that come with probabilistic accuracy guarantees. For a property P , the goal is to distinguish inputs that have P from those that are far from having P with high probability correctly, by querying only a small number of local parts of the input. In property testing on graphs, the distance is measured by the number of edge modifications (additions or deletions) that are necessary to transform a graph into one with property P . Much research has focused on the query complexity of such algorithms, i. e., the number of queries the algorithm makes to the input, but in view of applications, the running time of the algorithm is equally relevant. In (Adler, Harwath, STACS 2018), a natural extension of the bounded degree graph model of property testing to relational databases of bounded degree was introduced, and it was shown that on databases of bounded degree and bounded tree-width, every property that is expressible in monadic second-order logic with counting (CMSO) is testable with constant query complexity and sublinear running time. It remains open whether this can be improved to constant running time. In this article we introduce a new model, which is based on the bounded degree model, but the distance measure allows both edge (tuple) modifications and vertex (element) modifications. We show that every property that is testable in the classical model is testable in our model with the same query complexity and running time, but the converse is not true. Our main theorem shows that on databases of bounded degree and bounded tree-width, every property that is expressible in CMSO is testable with constant query complexity and constant running time in the new model. Our proof methods include the semilinearity of the neighborhood histograms of databases having the property and a result by Alon (Proposition 19.10 in Lovász, Large networks and graph limits, 2012) that states that for every bounded degree graph \(\mathcal {G}\) there exists a constant size graph \(\mathcal {H}\) that has a similar neighborhood distribution to \(\mathcal {G}\) . It can be derived from a result in (Benjamini et al., Advances in Mathematics 2010) that hyperfinite hereditary properties are testable with constant query complexity and constant running time in the classical model (and hence in the new model). Using our methods, we give an alternative proof that hyperfinite hereditary properties are testable with constant query complexity and constant running time in the new model. We argue that our model is natural and our meta-theorem showing constant-time CMSO testability supports this.

MSO undecidability for hereditary classes of unbounded clique-width

Seese’s conjecture for finite graphs states that monadic second-order logic (MSO) is undecidable on all graph classes of unbounded clique-width. We show that to establish this it would suffice to show that grids of unbounded size can be interpreted in two families of graph classes: minimal hereditary classes of unbounded clique-width; and antichains of unbounded clique-width under the induced subgraph relation. We explore all the currently known classes of the former category and establish that grids of unbounded size can indeed be interpreted in them.

A Robust Theory of Series Parallel Graphs

Motivated by distributed data processing applications, we introduce a class of labeled directed acyclic graphs constructed using sequential and parallel composition operations, and study automata and logics over them. We show that deterministic and non-deterministic acceptors over such graphs have the same expressive power, which can be equivalently characterized by Monadic Second-Order logic and the graded µ-calculus. We establish closure under composition operations and decision procedures for membership, emptiness, and inclusion. A key feature of our graphs, called synchronized series-parallel graphs (SSPG), is that parallel composition introduces a synchronization edge from the newly introduced source vertex to the sink. The transfer of information enabled by such edges is crucial to the determinization construction, which would not be possible for the traditional definition of series-parallel graphs. SSPGs allow both ordered ranked parallelism and unordered unranked parallelism. The latter feature means that in the corresponding automata, the transition function needs to account for an arbitrary number of predecessors by counting each type of state only up to a specified constant, thus leading to a notion of counting complexity that is distinct from the classical notion of state complexity. The determinization construction translates a nondeterministic automaton with n states and k counting complexity to a deterministic automaton with 2 n 2 states and kn counting complexity, and both these bounds are shown to be tight. Furthermore, for nondeterministic automata a bound of 2 on counting complexity suffices without loss of expressiveness.

Monadic second-order logic and the domino problem on self-similar graphs

We consider the domino problem on Schreier graphs of self-similar groups, and more generally their monadic second-order logic. On the one hand, we prove that if the group is bounded, then the domino problem on the graph is decidable; furthermore, under an ultimate periodicity condition, all its monadic second-order logic is decidable. This covers, for example, the Sierpiński gasket graphs and the Schreier graphs of the Basilica group. On the other hand, we prove undecidability of the domino problem for a class of self-similar groups, answering a question by Barbieri and Sablik, and study some examples including one of linear growth.