arXiv subjects

Joachim Niehren

Publications and source records attributed to Joachim Niehren.

8 recordsLinked to original sources

arXiv2026

Abstract Simulation of Reaction Networks

Reaction networks model reactions between a finite set of species. These networks can be associated with different semantics, depending on the type of analysis and the phenomena under study. The standard continuous semantics is given by a system of differential equations based on the kinetic expressions of the reactions. To simulate a network under this semantics, the full knowledge of the kinetic laws of each reaction and the initial concentrations of each species is necessary. Since in empirical settings the quantitative information about the reactions can be partially or totally unknown, the challenge is to introduce new semantics that can still be applied. In this direction, a recent approach in the state of the art concerning Reaction Networks proposes a qualitative abstraction that is too coarse to properly capture the time-course continuous behaviour. Starting from the ideas of this approach, in this paper we first introduce the causal continuous semantics for Reaction Networks to capture their continuous-time dynamics, preserving the causality hidden inside each transition. Later, we introduce the differential sign semantics to abstract in a qualitative way the behaviour of a system under the causal continuous semantics. We show that our new method, based on abstract interpretation, yields appropriate Boolean transition graphs that refine those provided by the previous approach.

cs.DM↗

arXiv2024

Linear Programs with Conjunctive Database Queries

In this paper, we study the problem of optimizing a linear program whose variables are the answers to a conjunctive query. For this we propose the language LP(CQ) for specifying linear programs whose constraints and objective functions depend on the answer sets of conjunctive queries. We contribute an efficient algorithm for solving programs in a fragment of LP(CQ). The natural approach constructs a linear program having as many variables as there are elements in the answer set of the queries. Our approach constructs a linear program having the same optimal value but fewer variables. This is done by exploiting the structure of the conjunctive queries using generalized hypertree decompositions of small width to factorize elements of the answer set together. We illustrate the various applications of LP(CQ) programs on three examples: optimizing deliveries of resources, minimizing noise for differential privacy, and computing the s-measure of patterns in graphs as needed for data mining.

cs.DB↗

arXiv2022

Schema-Based Automata Determinization

We propose an algorithm for schema-based determinization of finite automata on words and of step-wise hedge automata on nested words. The idea is to integrate schema-based cleaning directly into automata determinization. We prove the correctness of our new algorithm and show that it is alway smore efficient than standard determinization followed by schema-based cleaning. Our implementation permits to obtain a small deterministic automaton for an example of an XPath query, where standard determinization yields a huge stepwise hedge automaton for which schema-based cleaning runs out of memory.

cs.FL↗

arXiv2022

Jumping Evaluation of Nested Regular Path Queries

Nested regular path queries are used for querying graph databases and RDF triple stores. We propose a new algorithm for evaluating nested regular path queries on a graph from a set of start nodes in combined linear time. We show that this complexity upper bound can be reduced by making it dependent on the size of the query's top-down needed subgraph, a notion that we introduce. For many queries in practice, the top-down needed subgraph is way smaller than the whole graph. Our algorithm is based on a novel compilation schema from nested regular path queries to monadic datalog queries. Its complexity upper bound follows from known properties of top-down datalog evaluation. As an application, we show that our algorithm permits to reformulate in simple terms a variant of a very efficient automata-based algorithm proposed by Maneth and Nguyen that evaluates navigational path queries in datatrees based on indexes and jumping. Moreover, it overcomes some limitations of Maneth and Nguyen's: it is not bound to trees and applies to graphs; it is not limited to forward navigational XPath but can treat any nested regular path query and it can be implemented efficiently without any dedicated techniques, by using any efficient datalog evaluator such as LogicBlox.

cs.CC↗

arXiv2019

Solving linear programs on factorized databases

A typical workflow for solving a linear programming problem is to first write a linear program parametrized by the data in a language such as Math GNU Prog or AMPL then call the solver on this program while providing the data. When the data is extracted using a query on a database, this approach ignores the underlying structure of the answer set which may result in a blow-up of the size of the linear program if the answer set is big. In this paper, we study the problem of solving linear programming problems whose variables are the answers to a conjunctive query. We show that one can exploit the structure of the query to rewrite the linear program so that its size depends only on the size of the database and not on the size of the answer set. More precisely, we give a generic way of rewriting a linear program whose variables are the tuples in Q(D) for a conjunctive query Q and a database D into a linear program having a number of variables that only depends on the size of a factorized representation of Q(D), which can be much smaller when the fractional hypertree width of Q is bounded.

cs.DB↗

arXiv2019

Proceedings Fifth International Workshop on Rewriting Techniques for Program Transformations and Evaluation

This volume contains the formal proceedings of the 5th International Workshop on Rewriting Techniques for Program Transformations and Evaluation (WPTE 2018), held on 8th of Juli 2018 in Oxford, United Kingdom, and affiliated with FLoC 2018 and FSCD 2018. Scope of WPTE: Rewriting techniques are of great help for studying correctness of program transformations, translations and evaluation, and the aim of WPTE is to bring together the researchers working on program transformations, evaluation, and operationally-based programming language semantics, using rewriting methods, in order to share the techniques and recent developments and to exchange ideas to encourage further activation of research in this area. Topics in the scope of WPTE include the correctness of program transformations, optimisations and translations; program transformations for proving termination, confluence and other properties; correctness of evaluation strategies; operational semantics of programs, operationally-based program equivalences such as contextual equivalences and bisimulations; cost-models for reasoning about the optimizing power of transformations and the costs of evaluation; program transformations for verification and theorem proving purposes; translation, simulation, equivalence of programs with different formalisms, and evaluation strategies; program transformations for applying rewriting techniques to programs in specific programming languages; program transformations for program inversions and program synthesis; program transformation and evaluation for Haskell and rewriting. Research Paper Selection: At the workshop six research papers were presented of which five were accepted for the postproceedings. Each submission was reviewed by three or four members of the Program Committee in two to three rounds, one round for workshop presentation and at most two rounds for publication to the postproceedings. The program also included one invited talk by Jean-Pierre Jouannaud (Polytec, Palaiseau, Grand Paris, France) on a framework for graph rewriting; the abstract of this talk is included in this volume.

cs.PL↗

arXiv2014

Deterministic Automata for Unordered Trees

Automata for unordered unranked trees are relevant for defining schemas and queries for data trees in Json or Xml format. While the existing notions are well-investigated concerning expressiveness, they all lack a proper notion of determinism, which makes it difficult to distinguish subclasses of automata for which problems such as inclusion, equivalence, and minimization can be solved efficiently. In this paper, we propose and investigate different notions of "horizontal determinism", starting from automata for unranked trees in which the horizontal evaluation is performed by finite state automata. We show that a restriction to confluent horizontal evaluation leads to polynomial-time emptiness and universality, but still suffers from coNP-completeness of the emptiness of binary intersections. Finally, efficient algorithms can be obtained by imposing an order of horizontal evaluation globally for all automata in the class. Depending on the choice of the order, we obtain different classes of automata, each of which has the same expressiveness as CMso.

cs.FL↗

arXiv1995

Weak subsumption Constraints for Type Diagnosis: An Incremental Algorithm

We introduce constraints necessary for type checking a higher-order concurrent constraint language, and solve them with an incremental algorithm. Our constraint system extends rational unification by constraints x$\subseteq$ y saying that ``$x$ has at least the structure of $y$'', modelled by a weak instance relation between trees. This notion of instance has been carefully chosen to be weaker than the usual one which renders semi-unification undecidable. Semi-unification has more than once served to link unification problems arising from type inference and those considered in computational linguistics. Just as polymorphic recursion corresponds to subsumption through the semi-unification problem, our type constraint problem corresponds to weak subsumption of feature graphs in linguistics. The decidability problem for \WhatsIt for feature graphs has been settled by Dörre~\cite{Doerre:WeakSubsumption:94}. \nocite{RuppRosnerJohnson:94} In contrast to Dörre's, our algorithm is fully incremental and does not refer to finite state automata. Our algorithm also is a lot more flexible. It allows a number of extensions (records, sorts, disjunctive types, type declarations, and others) which make it suitable for type inference of a full-fledged programming language.

cmp-lg↗