A Model of Cooperative Threads

We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a trace-based denotational semantics for this language; this semantics is fully abstract but mathematically elementary. We also give an equational theory for the computational effects that underlie the language, including thread spawning. We then analyze threads in terms of the free algebra monad for this theory.Comment: 39 pages, 5 figure

Synchronous Kleene algebra

AbstractThe work presented here investigates the combination of Kleene algebra with the synchrony model of concurrency from Milner’s SCCS calculus. The resulting algebraic structure is called synchronous Kleene algebra. Models are given in terms of sets of synchronous strings and finite automata accepting synchronous strings. The extension of synchronous Kleene algebra with Boolean tests is presented together with models on sets of guarded synchronous strings and the associated automata on guarded synchronous strings. Completeness w.r.t. the standard interpretations is given for each of the two new formalisms. Decidability follows from completeness. Kleene algebra with synchrony should be included in the class of true concurrency models. In this direction, a comparison with Mazurkiewicz traces is made which yields their incomparability with synchronous Kleene algebras (one cannot simulate the other). On the other hand, we isolate a class of pomsets which captures exactly synchronous Kleene algebras. We present an application to Hoare-like reasoning about parallel programs in the style of synchrony

Deductive Verification of Concurrent Programs

Verification of concurrent programs still poses one of the major challenges in computer science. Several techniques to tackle this problem have been proposed. However, they often do not scale. We present an adaptation of the rely/guarantee methodology in dynamic logic. Rely/guarantee uses functional specification to symbolically describe the behavior of concurrently running threads: while each thread guarantees adherence to a specified property at any point in time, all other threads can rely on this property being established. This allows to regard threads largely in isolation--only w.r.t. an environment constrained by these specifications. While rely/guarantee based approaches often suffer from a considerable specification overhead, we complement functional thread specifications with frame conditions. We will explain our approach using a simple, but concurrent programing language. Besides the usual constructs for sequential programs, it caters for dynamic thread creation. We define semantics of concurrent programs w.r.t. an underspecified deterministic scheduling function. To formally reason about programs of this language, we introduce a novel multi-modal logic, Concurrent Dynamic Trace Logic (CDTL). It combines the strengthes of dynamic logic with those of linear temporal logic and allows to express temporal properties about symbolic program traces. We first develop a sound and complete sequent calculus for the logic subset that uses the sequential part of the language, based on symbolic execution. In a second step, we extend this to a calculus for the complete logic by adding symbolic execution rules for concurrent interleavings and dynamic thread creation based on the rely/guarantee methodology. Again, this calculus is proven sound and complete

Labeled natural deduction for temporal logics

Nonostante la notevole rilevanza delle logiche temporali in molti campi dell'informatica, la loro analisi teorica non è certo da ritenersi conclusa. In particolare, molti sono i punti ancora aperti nell'ambito della teoria della dimostrazione, specialmente se consideriamo le logiche temporali di tipo branching. Il principale contributo di questa tesi consiste nella presentazione di un approccio modulare per la definizione di sistemi di deduzione naturale etichettata per un'ampia gamma di logiche temporali. Viene innanzitutto proposto un sistema per la logica temporale minimale di Prior; si mostra quindi come estenderlo in maniera modulare allo scopo di trattare logiche più complesse, quali ad esempio LTL. Viene infine proposta un'estensione al caso delle logiche branching, concentrando l'attenzione sulle logiche con semantica di tipo Ockhamist e bundled. Per i sistemi proposti, viene condotta una dettagliata analisi dal punto di vista della teoria della dimostrazione. In particolare, nel caso delle logiche del tempo discreto, per le quali si richiedono regole che modellino un principio di induzione, viene definita una procedura di normalizzazione ispirata da quelle dei sistemi per l'Aritmetica di Heyting. Come conseguenza, si ottiene una dimostrazione puramente sintattica della consistenza dei sistemi.Despite the great relevance of temporal logics in many applications of computer science, their theoretical analysis is far from being concluded. In particular, we still lack a satisfactory proof theory for temporal logics and this is especially true in the case of branching-time logics. The main contribution of this thesis consists in presenting a modular approach to the definition of labeled (natural) deduction systems for a large class of temporal logics. We start by proposing a system for the basic Priorean tense logic and show how to modularly enrich it in order to deal with more complex logics, like LTL. We also consider the extension to the branching case, focusing on the Ockhamist branching-time logics with a bundled semantics. A detailed proof-theoretical analysis of the systems is performed. In particular, in the case of discrete-time logics, for which rules modeling an induction principle are required, we define a procedure of normalization inspired to those of systems for Heyting Arithmetic. As a consequence of normalization, we obtain a purely syntactical proof of the consistency of the systems

Deductive Verification of Concurrent Programs and its Application to Secure Information Flow for Java

Formal verification of concurrent programs still poses a major challenge in computer science. Our approach is an adaptation of the modular rely/guarantee methodology in dynamic logic. Besides functional properties, we investigate language-based security. Our verification approach extends naturally to multi-threaded Java and we present an implementation in the KeY verification system. We propose natural extensions to JML regarding both confidentiality properties and multi-threaded programs