39 research outputs found
Formalising Futures and Promises in Viper
National audienceFutures and promises are respectively a read-only and a write-once pointer to a placeholder in memory. They are used to transfer information between threads in the context of asynchronous concurrent programming. Futures and promises simplify the implementation of synchronisation mechanisms between threads. Nonetheless they can be error prone as data races may arise when references are shared and transferred. We aim at providing a formal tool to detect those errors. Hence, in this paper we propose a proof of concept by implementing the future/promise mechanism in Viper: a verification infrastructure, that provides a way to reason about resource ownership in programs
Decidability and Complexity of Tree Share Formulas
Fractional share models are used to reason about how multiple actors share ownership of resources. We examine the decidability and complexity of reasoning over the "tree share" model of Dockins et al. using first-order logic, or fragments thereof. We pinpoint a connection between the basic operations on trees union, intersection, and complement and countable atomless Boolean algebras, allowing us to obtain decidability with the precise complexity of both first-order and existential theories over the tree share model with the aforementioned operations. We establish a connection between the multiplication operation on trees and the theory of word equations, allowing us to derive the decidability of its existential theory and the undecidability of its full first-order theory. We prove that the full first-order theory over the model with both the Boolean operations and the restricted multiplication operation (with constants on the right hand side) is decidable via an embedding to tree-automatic structures
Learning-Based Synthesis of Safety Controllers
We propose a machine learning framework to synthesize reactive controllers
for systems whose interactions with their adversarial environment are modeled
by infinite-duration, two-player games over (potentially) infinite graphs. Our
framework targets safety games with infinitely many vertices, but it is also
applicable to safety games over finite graphs whose size is too prohibitive for
conventional synthesis techniques. The learning takes place in a feedback loop
between a teacher component, which can reason symbolically about the safety
game, and a learning algorithm, which successively learns an overapproximation
of the winning region from various kinds of examples provided by the teacher.
We develop a novel decision tree learning algorithm for this setting and show
that our algorithm is guaranteed to converge to a reactive safety controller if
a suitable overapproximation of the winning region can be expressed as a
decision tree. Finally, we empirically compare the performance of a prototype
implementation to existing approaches, which are based on constraint solving
and automata learning, respectively
RustHorn: CHC-based Verification for Rust Programs (full version)
Reduction to the satisfiability problem for constrained Horn clauses (CHCs)
is a widely studied approach to automated program verification. The current
CHC-based methods for pointer-manipulating programs, however, are not very
scalable. This paper proposes a novel translation of pointer-manipulating Rust
programs into CHCs, which clears away pointers and memories by leveraging
ownership. We formalize the translation for a simplified core of Rust and prove
its correctness. We have implemented a prototype verifier for a subset of Rust
and confirmed the effectiveness of our method.Comment: Full version of the same-titled paper in ESOP202
Syntactic Generation of Research Thesis Sketches Across Disciplines Using Formal Grammars
A part of the prerequisites for granting a degree in higher education institutions, students at postgraduate levels normally carry out research, which they do report in the form of theses or dissertations. Study has shown that students tend to go through difficulties in writing research thesis across all disciplines because they do not fully comprehend what constitutes a research thesis. This project proposes the syntactic generation of research thesis sketches across disciplines using formal grammars. Sketching is a synthesis technique which enables users to deliver high-level intuitions into a synthesis snag while leaving low-level details to synthesis tools. This work extends sketching to document generation for research thesis documents. Context-free grammar rules were designed and implemented for this task. A link to 10,000 generated thesis sketches was presented
Artificial Collective Intelligence Engineering: a Survey of Concepts and Perspectives
Collectiveness is an important property of many systems--both natural and
artificial. By exploiting a large number of individuals, it is often possible
to produce effects that go far beyond the capabilities of the smartest
individuals, or even to produce intelligent collective behaviour out of
not-so-intelligent individuals. Indeed, collective intelligence, namely the
capability of a group to act collectively in a seemingly intelligent way, is
increasingly often a design goal of engineered computational systems--motivated
by recent techno-scientific trends like the Internet of Things, swarm robotics,
and crowd computing, just to name a few. For several years, the collective
intelligence observed in natural and artificial systems has served as a source
of inspiration for engineering ideas, models, and mechanisms. Today, artificial
and computational collective intelligence are recognised research topics,
spanning various techniques, kinds of target systems, and application domains.
However, there is still a lot of fragmentation in the research panorama of the
topic within computer science, and the verticality of most communities and
contributions makes it difficult to extract the core underlying ideas and
frames of reference. The challenge is to identify, place in a common structure,
and ultimately connect the different areas and methods addressing intelligent
collectives. To address this gap, this paper considers a set of broad scoping
questions providing a map of collective intelligence research, mostly by the
point of view of computer scientists and engineers. Accordingly, it covers
preliminary notions, fundamental concepts, and the main research perspectives,
identifying opportunities and challenges for researchers on artificial and
computational collective intelligence engineering.Comment: This is the author's final version of the article, accepted for
publication in the Artificial Life journal. Data: 34 pages, 2 figure
Local Reasoning for Global Graph Properties
Separation logics are widely used for verifying programs that manipulate
complex heap-based data structures. These logics build on so-called separation
algebras, which allow expressing properties of heap regions such that
modifications to a region do not invalidate properties stated about the
remainder of the heap. This concept is key to enabling modular reasoning and
also extends to concurrency. While heaps are naturally related to mathematical
graphs, many ubiquitous graph properties are non-local in character, such as
reachability between nodes, path lengths, acyclicity and other structural
invariants, as well as data invariants which combine with these notions.
Reasoning modularly about such graph properties remains notoriously difficult,
since a local modification can have side-effects on a global property that
cannot be easily confined to a small region.
In this paper, we address the question: What separation algebra can be used
to avoid proof arguments reverting back to tedious global reasoning in such
cases? To this end, we consider a general class of global graph properties
expressed as fixpoints of algebraic equations over graphs. We present
mathematical foundations for reasoning about this class of properties, imposing
minimal requirements on the underlying theory that allow us to define a
suitable separation algebra. Building on this theory we develop a general proof
technique for modular reasoning about global graph properties over program
heaps, in a way which can be integrated with existing separation logics. To
demonstrate our approach, we present local proofs for two challenging examples:
a priority inheritance protocol and the non-blocking concurrent Harris list