Filters








59 Hits in 0.76 sec

Dynamic Graph Queries [article]

Pablo Muñoz and Nils Vortmeier and Thomas Zeume
2015 arXiv   pre-print
Graph databases in many applications---semantic web, transport or biological networks among others---are not only large, but also frequently modified. Evaluating graph queries in this dynamic context is a challenging task, as those queries often combine first-order and navigational features. Motivated by recent results on maintaining dynamic reachability, we study the dynamic evaluation of traditional query languages for graphs in the descriptive complexity framework. Our focus is on
more » ... regular path queries, and extensions thereof, by first-order formulas. In particular we are interested in path queries defined by non-regular languages and in extended conjunctive regular path queries (which allow to compare labels of paths based on word relations). Further we study the closely related problems of maintaining distances in graphs and reachability in product graphs. In this preliminary study we obtain upper bounds for those problems in restricted settings, such as undirected and acyclic graphs, or under insertions only, and negative results regarding quantifier-free update formulas. In addition we point out interesting directions for further research.
arXiv:1512.05511v1 fatcat:3utoxdfn5bhqjdta254yv6orri

Dynamic Complexity under Definable Changes [article]

Thomas Schwentick, Nils Vortmeier, Thomas Zeume
2017 arXiv   pre-print
This paper studies dynamic complexity under definable change operations in the DynFO framework by Patnaik and Immerman. It is shown that for changes definable by parameter-free first-order formulas, all (uniform) AC^1 queries can be maintained by first-order dynamic programs. Furthermore, many maintenance results for single-tuple changes are extended to more powerful change operations: (1) The reachability query for undirected graphs is first-order maintainable under single tuple changes and
more » ... st-order defined insertions, likewise the reachability query for directed acyclic graphs under quantifier-free insertions. (2) Context-free languages are first-order maintainable under Σ_1-defined changes. These results are complemented by several inexpressibility results, for example, that the reachability query cannot be maintained by quantifier-free programs under definable, quantifier-free deletions.
arXiv:1701.02494v1 fatcat:chc2ykokznf3tfaum57qrsugnm

The Dynamic Complexity of Acyclic Hypergraph Homomorphisms [article]

Nils Vortmeier, Ioannis Kokkinis
2021 arXiv   pre-print
Finding a homomorphism from some hypergraph 𝒬 (or some relational structure) to another hypergraph 𝒟 is a fundamental problem in computer science. We show that an answer to this problem can be maintained under single-edge changes of 𝒬, as long as it stays acyclic, in the DynFO framework of Patnaik and Immerman that uses updates expressed in first-order logic. If additionally also changes of 𝒟 are allowed, we show that it is unlikely that existence of homomorphisms can be maintained in DynFO.
arXiv:2107.06121v1 fatcat:funl2lugqvfvdphfl4y6y2yphe

Givens QR Decomposition over Relational Databases [article]

Dan Olteanu, Nils Vortmeier, Đorđe Živanović
2022 arXiv   pre-print
This paper introduces Figaro, an algorithm for computing the upper-triangular matrix in the QR decomposition of the matrix defined by the natural join over a relational database. The QR decomposition lies at the core of many linear algebra techniques and their machine learning applications, including: the matrix inverse; the least squares; the singular value decomposition; eigenvalue problems; and the principal component analysis. Figaro's main novelty is that it pushes the QR decomposition
more » ... the join. This leads to several desirable properties. For acyclic joins, it takes time linear in the database size and independent of the join size. Its execution is equivalent to the application of a sequence of Givens rotations proportional to the join size. Its number of rounding errors relative to the classical QR decomposition algorithms is on par with the input size relative to the join size. In experiments with real-world and synthetic databases, Figaro outperforms both in runtime performance and accuracy the LAPACK libraries openblas and Intel MKL by a factor proportional to the gap between the join output and input sizes.
arXiv:2204.00525v1 fatcat:hlzasrospjf5bdff4jvatc56cu

Reachability and Distances under Multiple Changes [article]

Samir Datta, Anish Mukherjee, Nils Vortmeier, Thomas Zeume
2018 arXiv   pre-print
Recently it was shown that the transitive closure of a directed graph can be updated using first-order formulas after insertions and deletions of single edges in the dynamic descriptive complexity framework by Dong, Su, and Topor, and Patnaik and Immerman. In other words, Reachability is in DynFO. In this article we extend the framework to changes of multiple edges at a time, and study the Reachability and Distance queries under these changes. We show that the former problem can be maintained
more » ... DynFO(+, ×) under changes affecting O( n/ n) nodes, for graphs with n nodes. If the update formulas may use a majority quantifier then both Reachability and Distance can be maintained under changes that affect O(^c n) nodes, for fixed c ∈N. Some preliminary results towards showing that distances are in DynFO are discussed.
arXiv:1804.08555v1 fatcat:eydrzofihbcrvlvqtqpjvu3ywa

Static Analysis for Logic-Based Dynamic Programs [article]

Thomas Schwentick, Nils Vortmeier, Thomas Zeume
2015 arXiv   pre-print
Some of the results shown in this paper have been already presented in the master thesis of Nils Vortmeier [23] .  ... 
arXiv:1507.04537v1 fatcat:kd3kl7nlbzgjhlskvaywh6cf3u

Work-sensitive Dynamic Complexity of Formal Languages [article]

Jonas Schmidt, Thomas Schwentick, Till Tantau, Nils Vortmeier, Thomas Zeume
2021 arXiv   pre-print
Which amount of parallel resources is needed for updating a query result after changing an input? In this work we study the amount of work required for dynamically answering membership and range queries for formal languages in parallel constant time with polynomially many processors. As a prerequisite, we propose a framework for specifying dynamic, parallel, constant-time programs that require small amounts of work. This framework is based on the dynamic descriptive complexity framework by Patnaik and Immerman.
arXiv:2101.08735v1 fatcat:43xo4flikzfivpqqkfcu7gphfe

Dynamic Complexity Meets Parameterised Algorithms [article]

Jonas Schmidt, Thomas Schwentick, Nils Vortmeier, Thomas Zeume, Ioannis Kokkinis
2019 arXiv   pre-print
Samir Datta, Anish Mukherjee, Thomas Schwentick, Nils Vortmeier, and Thomas Zeume. A strategy for Dynamic Programs: Start over and Muddle through. Rodney G.  ... 
arXiv:1910.06281v2 fatcat:kqxvs46ed5cblkuj2liutee2m4

Dynamic Graph Queries

Pablo Muñoz, Nils Vortmeier, Thomas Zeume, Marc Herbstritt
2016 International Conference on Database Theory  
Vortmeier, and T.  ...  Vortmeier, and T. Zeume 14:15 which is NP-hard. This follows from a reduction from emptiness of intersections of unary regular expressions which is known to be NP-hard [10] . Corollary 17.  ... 
doi:10.4230/lipics.icdt.2016.14 dblp:conf/icdt/MunozVZ16 fatcat:f4owlmo3kzhjxcqozvg645e5ja

Dynamic complexity of Reachability: How many changes can we handle? [article]

Samir Datta, Pankaj Kumar, Anish Mukherjee, Anuj Tawari, Nils Vortmeier, Thomas Zeume
2020 arXiv   pre-print
Parts of the results presented here have been included in the PhD thesis of Nils Vortmeier [26] .  ...  Nils Vortmeier. Dynamic expressibility under complex changes. PhD thesis, TU Dortmund University, Germany, 2019. doi:10.17877/DE290R-20434.  ... 
arXiv:2004.12739v1 fatcat:ml337i6yhbg6hpok3hbr3d7yym

Dynamic Complexity Meets Parameterised Algorithms

Jonas Schmidt, Thomas Schwentick, Nils Vortmeier, Thomas Zeume, Ioannis Kokkinis, Michael Wagner
2020 Annual Conference for Computer Science Logic  
Dynamic Complexity studies the maintainability of queries with logical formulas in a setting where the underlying structure or database changes over time. Most often, these formulas are from firstorder logic, giving rise to the dynamic complexity class DynFO. This paper investigates extensions of DynFO in the spirit of parameterised algorithms. In this setting structures come with a parameter k and the extensions allow additional "space" of size f (k) (in the form of an additional structure of
more » ... his size) or additional time f (k) (in the form of iterations of formulas) or both. The resulting classes are compared with their non-dynamic counterparts and other classes. The main part of the paper explores the applicability of methods for parameterised algorithms to this setting through case studies for various well-known parameterised problems. ACM Subject Classification Theory of computation → Parameterized complexity and exact algorithms; Theory of computation → Logic and databases; Theory of computation → Complexity theory and logic This paper adds the aspect of changing inputs and dynamic maintenance of results to the exploration of the landscape between para-AC 0 and FPT. The study of low-level complexity classes under dynamic aspects was started in [30, 15] in the context of dynamically maintaining the result of database queries. Similarly, as for dynamic algorithms, in this setting a dynamic program can make use of auxiliary relations that can store knowledge about the current input data (database). After a small change of the database (most often: insertion or deletion of a tuple), the program needs to compute the query result for the modified database in very short parallel time. To capture the problems/queries, for which this is possible, Patnaik and Immerman introduced the class DynFO [30]. Here, "FO" stands for first-order logic, which is equivalent to AC 0 , in the presence of arithmetic [7, 24] . In this paper, we study dynamic programs that have additional resources in a "parameterised sense". We explore two such resources, which can be described as parameterised space and parameterised time, respectively. For ease of exposition, we discuss these two resources in the context of AC 0 first. One way to strengthen AC 0 circuit families is to allow circuits of size f (k)poly(|x|). We denote the class thus obtained as para-S-AC 0 (even though it corresponds to the class para-AC 0 ). A second dimension is to let the depth of circuits depend on the parameter. As the depth of circuits corresponds to the (parallel) time the circuits need for a computation, we denote the class of problems captured by such circuits by para-T-AC 0 . Of course, both dimensions can also be combined, yielding the parameterised class para-ST-AC 0 . Surprisingly, several parameterised versions of NP-complete problems can even be solved in para-S-AC 0 . Examples are the vertex cover problem and the hitting set problem parameterised by the size of the vertex cover and the hitting set, respectively [4] . However, classical circuit lower bounds unconditionally imply that this is not possible for all in [3] it was observed that the existence of simple paths of length k (the parameter) cannot be tested in para-S-AC 0 . Likewise, the feedback vertex set problem with the size of the feedback vertex set as parameter cannot be solved in para-ST-AC 0 . When translated from circuits to logical formulas, depth roughly translates into iteration of formulas [24, Theorem 5.22], whereas size translates into the size of an additional structure by which the database is extended before formulas are evaluated. Slightly more formally, para-T-AC 0 corresponds to the class para-T-FO consisting of problems that can be defined by iterating a formula f (k) many times. The class para-S-AC 0 corresponds to the class para-S-FO where formulas are evaluated on structures D extended by an advice structure whose size depends on the parameter only. In the class para-ST-FO both dimensions are combined. The parameterised dynamic classes that we study in this paper are obtained from DynFO just like the above classes are obtained from FO: para-S-DynFO, para-T-DynFO and para-ST-DynFO extend DynFO by an additional structure of parameterised size, f (k) iterations of formulas, or both, respectively. As our first main contribution, we introduce a uniform framework for small dynamic, parameterised complexity classes (Section 3) based on advice structures (corresponding to additional space) or iterations of formulas (corresponding to additional time) and investigate how the resulting classes relate to each other and to other non-dynamic (and even nonparameterised) complexity classes (Section 4). As our second main contribution, we explore how methods for parameterised algorithms can be applied in this framework through case studies for various parameterised problems (Section 5). Due to space limitations, many proofs are omitted and can be found in the full version of this paper.
doi:10.4230/lipics.csl.2020.36 dblp:conf/csl/SchmidtSVZK20 fatcat:u3bofincu5euri7b6w6xu5hgti

Dynamic Complexity of Parity Exists Queries

Nils Vortmeier, Thomas Zeume, Michael Wagner
2020 Annual Conference for Computer Science Logic  
Given a graph whose nodes may be coloured red, the parity of the number of red nodes can easily be maintained with first-order update rules in the dynamic complexity framework DynFO of Patnaik and Immerman. Can this be generalised to other or even all queries that are definable in first-order logic extended by parity quantifiers? We consider the query that asks whether the number of nodes that have an edge to a red node is odd. Already this simple query of quantifier structure parity-exists is
more » ... major roadblock for dynamically capturing extensions of first-order logic. We show that this query cannot be maintained with quantifier-free first-order update rules, and that variants induce a hierarchy for such update rules with respect to the arity of the maintained auxiliary relations. Towards maintaining the query with full first-order update rules, it is shown that degree-restricted variants can be maintained. ACM Subject Classification Theory of computation → Logic and databases; Theory of computation → Complexity theory and logic This simple program proves that Parity is in the dynamic complexity class DynFO which contains all queries that can be maintained via first-order formulas that use (and update) some additional stored auxiliary relations. Motivated by applications in database theory and complexity theory, the class DynFO has been studied extensively in the last three decades. In database theory it is well-known that first-order logic corresponds to the relational core of SQL (see, e.g., [1]). Thus, if a query can be maintained with first-order update rules then, in particular, it can be updated using SQL queries. From a complexity theoretic point of view, first-order logic with built-in arithmetic corresponds to the circuit complexity class uniform AC 0 [3]. Hence queries in DynFO can be evaluated in a highly parallel fashion in dynamic scenarios. The focus of research on DynFO has been its expressive power. The parity query is a first witness that DynFO is more expressive than FO (the class of queries expressible by first-order formulas in the standard, non-dynamic setting), but it is not the only witness. Further examples include the reachability query for general directed graphs [4], another textbook query that is not in FO but complete for the complexity class NL, which can be characterised (on ordered structures) by the extension of first-order logic with a transitive closure operator. On (classes of) graphs of bounded treewidth, DynFO includes all queries that can be defined in monadic second-order logic [5] , which extends first-order logic by quantification over sets. In particular, on strings DynFO also contains all MSO-definable Boolean queries, that is, all regular languages. Actually for strings the update rules do not need any quantifiers [10] proving that regular languages are even in the dynamic complexity class DynProp which is defined via quantifier-free first-order update rules. These examples show that dynamically first-order logic can, in some cases, sidestep quantifiers and operators which it cannot express statically: parity and set quantifiers, as well as transitive closure operators. Immediately the question arises whether first-order update rules can dynamically maintain all queries that are statically expressible in extensions of first-order logic by one of these quantifiers or operators. Note that this does not follow easily, for instance, from the result that the NL-complete reachability query is in DynFO, because the notions of reductions that are available in the dynamic setting are too weak [13] . The extension FO+Parity of first-order logic by parity quantifiers is the natural starting point for a more thorough investigation of how DynFO relates to extensions of FO, as it is arguably the simplest natural extension that extends the expressive power. Unfortunately, however, a result of the form FO+Parity ⊆ DynFO is not in sight 2 . While Parity is in DynFO, already for slightly more complex queries expressible in FO+Parity it seems not to be easy to show that they are in DynFO. In this paper we are particularly interested in the following generalisation of the parity query: ParityExists: Given a graph whose nodes may be coloured red. Is the number of nodes connected to a red node odd? Edges can be inserted and deleted; nodes can be coloured or uncoloured. As it is still unknown whether ParityExists is in DynFO, this query is a roadblock for showing that DynFO captures (large subclasses of) FO+Parity. For this reason we study the dynamic complexity of ParityExists. We focus on the following two directions: (1) its relation to the well-understood quantifier-free fragment DynProp of DynFO, and (2) the dynamic complexity of degree-restricted variants. 2 Formally one has to be a little more precise. For technical reasons, one cannot express the query "The size of the domain is even." in DynFO. Therefore we are interested in results of this form for domain-independent queries, that is, queries whose result does not change when isolated elements are added to the domain.
doi:10.4230/lipics.csl.2020.37 dblp:conf/csl/VortmeierZ20 fatcat:huh4qlycbzabtf6y5vur7ijz4i

A Strategy for Dynamic Programs: Start over and Muddle through

Samir Datta, Anish Mukherjee, Thomas Schwentick, Nils Vortmeier, Thomas Zeume
2019 Logical Methods in Computer Science  
Vortmeier, and T. Zeume Vol. 15:2 Basically, all isomorphism types of such graphs and their respective MSO types can be directly encoded into first-order formulas.  ...  Vortmeier, and T. Zeume Vol. 15:2 For such a triangle δ = (i0, i1, i2), the nodes i0, i1, i2 are exactly the special nodes in T (δ).12:22 S. Datta, A. Mukherjee, T. Schwentick, N.  ... 
doi:10.23638/lmcs-15(2:12)2019 fatcat:b2dobm7rzvbe3nhki542bourre

Reachability and Distances under Multiple Changes

Samir Datta, Anish Mukherjee, Nils Vortmeier, Thomas Zeume, Michael Wagner
2018 International Colloquium on Automata, Languages and Programming  
Recently it was shown that the transitive closure of a directed graph can be updated using firstorder formulas after insertions and deletions of single edges in the dynamic descriptive complexity framework by Dong, Su, and Topor, and Patnaik and Immerman. In other words, Reachability is in DynFO. In this article we extend the framework to changes of multiple edges at a time, and study the Reachability and Distance queries under these changes. We show that the former problem can be maintained in
more » ... DynFO(+, ×) under changes affecting O( log n log log n ) nodes, for graphs with n nodes. If the update formulas may use a majority quantifier then both Reachability and Distance can be maintained under changes that affect O(log c n) nodes, for fixed c ∈ N. Some preliminary results towards showing that distances are in DynFO are discussed.
doi:10.4230/lipics.icalp.2018.120 dblp:conf/icalp/Datta0VZ18 fatcat:bnp2mkzqengwjgxmrifytufxzq

Dynamic Complexity of Parity Exists Queries [article]

Nils Vortmeier, Thomas Zeume
2021 arXiv   pre-print
Vortmeier and T. Zeume Vol. 17:4 In case (1), the set N •• α(G) (A, B) equals the set N •• G (A\{v}, B∪{v}) , and the existing auxiliary information can be copied.  ...  Vortmeier and T. Zeume Vol. 17:4 such that for all strictly increasing sequences i 1 , . . . , i k+1 over [n]: (δ 1 (p i 1 ) • . . . • δ k+1 (p i k+1 ))(I) ∈ q ⇐⇒ {i 1 , . . . , i k+1 } ∈ B.  ...  Vortmeier and T. Zeume Vol. 17:4 ) The set both conditions (1) and (2) from above are satisfied regarding w and I.  ... 
arXiv:1910.06004v5 fatcat:ymmkwc5xkrdvpkq2afcdf4gada
« Previous Showing results 1 — 15 out of 59 results