41 research outputs found

    Dynamic Complexity of Planar 3-connected Graph Isomorphism

    Full text link
    Dynamic Complexity (as introduced by Patnaik and Immerman) tries to express how hard it is to update the solution to a problem when the input is changed slightly. It considers the changes required to some stored data structure (possibly a massive database) as small quantities of data (or a tuple) are inserted or deleted from the database (or a structure over some vocabulary). The main difference from previous notions of dynamic complexity is that instead of treating the update quantitatively by finding the the time/space trade-offs, it tries to consider the update qualitatively, by finding the complexity class in which the update can be expressed (or made). In this setting, DynFO, or Dynamic First-Order, is one of the smallest and the most natural complexity class (since SQL queries can be expressed in First-Order Logic), and contains those problems whose solutions (or the stored data structure from which the solution can be found) can be updated in First-Order Logic when the data structure undergoes small changes. Etessami considered the problem of isomorphism in the dynamic setting, and showed that Tree Isomorphism can be decided in DynFO. In this work, we show that isomorphism of Planar 3-connected graphs can be decided in DynFO+ (which is DynFO with some polynomial precomputation). We maintain a canonical description of 3-connected Planar graphs by maintaining a database which is accessed and modified by First-Order queries when edges are added to or deleted from the graph. We specifically exploit the ideas of Breadth-First Search and Canonical Breadth-First Search to prove the results. We also introduce a novel method for canonizing a 3-connected planar graph in First-Order Logic from Canonical Breadth-First Search Trees

    Dynamic Complexity of Parity Exists Queries

    Get PDF
    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 a 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

    Dynamic Graph Queries

    Get PDF
    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 maintaining 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

    Dynamic Complexity of Formal Languages

    Get PDF
    The paper investigates the power of the dynamic complexity classes DynFO, DynQF and DynPROP over string languages. The latter two classes contain problems that can be maintained using quantifier-free first-order updates, with and without auxiliary functions, respectively. It is shown that the languages maintainable in DynPROP exactly are the regular languages, even when allowing arbitrary precomputation. This enables lower bounds for DynPROP and separates DynPROP from DynQF and DynFO. Further, it is shown that any context-free language can be maintained in DynFO and a number of specific context-free languages, for example all Dyck-languages, are maintainable in DynQF. Furthermore, the dynamic complexity of regular tree languages is investigated and some results concerning arbitrary structures are obtained: there exist first-order definable properties which are not maintainable in DynPROP. On the other hand any existential first-order property can be maintained in DynQF when allowing precomputation.Comment: Contains the material presenten at STACS 2009, extendes with proofs and examples which were omitted due lack of spac

    Dynamic Complexity of Reachability: How Many Changes Can We Handle?

    Get PDF
    In 2015, it was shown that reachability for arbitrary directed graphs can be updated by first-order formulas after inserting or deleting single edges. Later, in 2018, this was extended for changes of size (log n)/(log log n), where n is the size of the graph. Changes of polylogarithmic size can be handled when also majority quantifiers may be used. In this paper we extend these results by showing that, for changes of polylogarithmic size, first-order update formulas suffice for maintaining (1) undirected reachability, and (2) directed reachability under insertions. For classes of directed graphs for which efficient parallel algorithms can compute non-zero circulation weights, reachability can be maintained with update formulas that may use "modulo 2" quantifiers under changes of polylogarithmic size. Examples for these classes include the class of planar graphs and graphs with bounded treewidth. The latter is shown here. As the logics we consider cannot maintain reachability under changes of larger sizes, our results are optimal with respect to the size of the changes
    corecore