131 research outputs found
On the semantics of fair parallelism
Suppose that a programming language involves, among other familiar ways of composing commands Ci, a "parallel" construct (C1 par C2) .
One expects, when using this language, that a sequence such as
x := O; y := 1; (x := 1 par (while x=0 do y := y+1)) should be guaranteed to terminate in whatever context it is executed
Deciding Conditional Termination
We address the problem of conditional termination, which is that of defining
the set of initial configurations from which a given program always terminates.
First we define the dual set, of initial configurations from which a
non-terminating execution exists, as the greatest fixpoint of the function that
maps a set of states into its pre-image with respect to the transition
relation. This definition allows to compute the weakest non-termination
precondition if at least one of the following holds: (i) the transition
relation is deterministic, (ii) the descending Kleene sequence
overapproximating the greatest fixpoint converges in finitely many steps, or
(iii) the transition relation is well founded. We show that this is the case
for two classes of relations, namely octagonal and finite monoid affine
relations. Moreover, since the closed forms of these relations can be defined
in Presburger arithmetic, we obtain the decidability of the termination problem
for such loops.Comment: 61 pages, 6 figures, 2 table
Optimization of Regular Path Queries in Graph Databases
Regular path queries offer a powerful navigational mechanism in graph databases. Recently, there has been renewed interest in such queries in the context of the Semantic Web. The extension of SPARQL in version 1.1 with property paths offers a type of regular path query for RDF graph databases. While eminently useful, such queries are difficult to optimize and evaluate efficiently, however. We design and implement a cost-based optimizer we call Waveguide for SPARQL queries with property paths. Waveguide builds a query planwhich we call a waveplan (WP)which guides the query evaluation. There are numerous choices in the con- struction of a plan, and a number of optimization methods, so the space of plans for a query can be quite large. Execution costs of plans for the same query can vary by orders of magnitude with the best plan often offering excellent performance. A WPs costs can be estimated, which opens the way to cost-based optimization. We demonstrate that Waveguide properly subsumes existing techniques and that the new plans it adds are relevant. We analyze the effective plan space which is enabled by Waveguide and design an efficient enumerator for it. We implement a pro- totype of a Waveguide cost-based optimizer on top of an open-source relational RDF store. Finally, we perform a comprehensive performance study of the state of the art for evaluation of SPARQL property paths and demonstrate the significant performance gains that Waveguide offers
Value constraints in the CLP scheme
This paper addresses the question of how to incorporate constraint propagation into logic programming. A likely candidate is the CLP scheme, which allows one to exploit algorithmic opportunities while staying within logic programming semantics. CLP() is an example: it combines logic programming with the algorithms for solving linear equalities and inequalities. In this paper we describe two contrasting constraint store management strategies within the CLP scheme. One leads to CLP(), while the other, which we call value constraints, supports consistency methods such as arc consistency and interval constraints. In value constraints, the infer step of the CLP scheme is the application of a consistency operator acting on the active constraints. We show how the continued application of the infer step can be optimized and that such optimization is equivalent to the Waltz algorithm for constraint propagation. Using the Lassez-Maher fixpoint theory of chaotic iterations, we show that the Waltz algorithm does not necessarily converge to a fixpoint, but that it does so in the finitary case
Value constraints in the CLP scheme
This paper addresses the question of how to incorporate constraint propagation into logic programming. A likely candidate is the CLP scheme, which allows one to exploit algorithmic opportunities while staying within logic programming semantics. CLP() is an example: it combines logic programming with the algorithms for solving linear equalities and inequalities. In this paper we describe two contrasting constraint store management strategies within the CLP scheme. One leads to CLP(), while the other, which we call value constraints, supports consistency methods such as arc consistency and interval constraints. In value constraints, the infer step of the CLP scheme is the application of a consistency operator acting on the active constraints. We show how the continued application of the infer step can be optimized and that such optimization is equivalent to the Waltz algorithm for constraint propagation. Using the Lassez-Maher fixpoint theory of chaotic iterations, we show that the Waltz algorithm does not necessarily converge to a fixpoint, but that it does so in the finitary case
Foundations of Software Science and Computation Structures
This open access book constitutes the proceedings of the 24th International Conference on Foundations of Software Science and Computational Structures, FOSSACS 2021, which was held during March 27 until April 1, 2021, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2021. The conference was planned to take place in Luxembourg and changed to an online format due to the COVID-19 pandemic. The 28 regular papers presented in this volume were carefully reviewed and selected from 88 submissions. They deal with research on theories and methods to support the analysis, integration, synthesis, transformation, and verification of programs and software systems
Automating Program Analysis For Differential Privacy
This dissertation explores techniques for automating program analysis, with a focus on validating and securely executing differentially private programs. Differential privacy allows analysts to study general patterns among individuals, while providing strong protections against identity leakage.
To automatically check differential privacy for programs, we develop Fuzzi: a three-level logic for differential privacy. Fuzziâs lowest level is a general-purpose logic; its middle level is apRHL, a program logic for mechanical construction of differential privacy proofs; and its top level is a novel sensitivity logic for tracking sensitivity bounds, a fundamental building block of differential privacy.
Some differentially private algorithms have sophisticated proofs that cannot be derived by a compositional typechecking process. To detect incorrect implementations for these algorithms, we develop DPCheck for testing differential privacy automatically. Adapting a well-known âpointwiseâ proof technique for differential privacy, DPCheck observes runtime program behaviors, and derives formulas that constrain potential privacy proofs.
Once we are convinced that a program is differentially private, we often still have to trust that the machine executing the program does not misbehave and leak sensitive results. For analytics at scale, computation is often delegated to networked computers that may become compromised. To securely run differentially private analytics at scale, we develop Orchard, a system that can answer many differentially private queries over data distributed among millions of user devices. Orchard leverages cryptographic primitives to employ untrusted computers, while preventing untrusted computers from observing sensitive results
Foundations of Software Science and Computation Structures
This open access book constitutes the proceedings of the 22nd International Conference on Foundations of Software Science and Computational Structures, FOSSACS 2019, which took place in Prague, Czech Republic, in April 2019, held as part of the European Joint Conference on Theory and Practice of Software, ETAPS 2019. The 29 papers presented in this volume were carefully reviewed and selected from 85 submissions. They deal with foundational research with a clear significance for software science
- âŠ