Compositional Reasoning for Side-effectful Iterators and Iterator Adapters

Iteration is a programming operation that traditionally refers to visiting the elements of a data structure in sequence. However, modern programming systems such as Rust, Java, and C# generalise iteration far beyond the traditional use case. They allow iterators to be parameterised with (potentially side-effectful) closures and support the composition of iterators to form iterator chains, where each iterator in the chain consumes values from its predecessor and produces values for its successor. Such generalisations pose three major challenges for modular specification and verification of iterators and the client code using them: (1) How can parameterised iterators be specified modularly and their (accumulated) side effects reasoned about? (2) How can the behaviour of an iterator chain be derived from the specifications of its component iterators? (3) How can proofs about such iterators be automated? We present the first methodology for the modular specification and verification of advanced iteration idioms with side-effectful computations. It addresses the three challenges above using a combination of inductive two-state invariants, higher-order closure contracts, and separation logiclike ownership. We implement and our methodology in a state-of-the-art SMT-based Rust verifier. Our evaluation shows that our methodology is sufficiently expressive to handle advanced and idiomatic iteration idioms and requires modest annotation overhead

Modular specification and verification of closures in Rust

Closures are a language feature supported by many mainstream languages, combining the ability to package up references to code blocks with the possibility of capturing state from the environment of the closure's declaration. Closures are powerful, but complicate understanding and formal reasoning, especially when closure invocations may mutate objects reachable from the captured state or from closure arguments. This paper presents a novel technique for the modular specification and verification of closure-manipulating code in Rust. Our technique combines Rust's type system guarantees and novel specification features to enable formal verification of rich functional properties. It encodes higher-order concerns into a first-order logic, which enables automation via SMT solvers. Our technique is implemented as an extension of the deductive verifier Prusti, with which we have successfully verified many common idioms of closure usage.ISSN:2475-142

Impact of the self-healing agent composition on material characteristics of bio-based self-healing concrete

This paper investigates the composition of the biological self-healing agent based on its impact on material characteristics of concrete. A direct addition of the agent – a mixture of bacterial spores and nutrients – into concrete matrix has been investigated by many studies in recent decades. Under certain conditions, the applied microorganisms proved to be able to produce CaCO3, and researchers used this biocalcification process to autonomously seal microcracks in concrete. Thus, this bio-based material could potentially heal itself and lead to a more durable and economic structure. However, it has been shown that the self-healing agent, especially the indispensable nutrients, can positively or negatively influence the material characteristics. In this study, some of the most suitable and frequently proposed nutrients (calcium lactate, calcium nitrate, calcium formate, urea, and yeast extract) were directly added into cement mortar during the mixing process and their impact on material characteristics – compressive strength, flexural strength, and rheology – was evaluated and compared. Results show that calcium nitrate, calcium formate, calcium lactate, and urea have generally a potential to increase the compressive strength, especially in early ages. In contrast, the applied dose of yeast extract resulted in a drastic drop of compressive strength when compared to the control series, thus further optimization of the concentration is needed. The flexural strength was affected rather negligibly by the proposed nutritional admixtures

The Prusti Project: Formal Verification for Rust

Rust is a modern systems programming language designed to offer both performance and static safety. A key distinguishing feature is a strong type system, which enforces by default that memory is either shared or mutable, but never both. This guarantee is used to prevent common pitfalls such as memory errors and data races. It can also be used to greatly simplify formal verification, as we demonstrated by developing the Prusti verifier, which can verify rich correctness properties of Rust programs with a very modest annotation overhead. In this paper, we provide an overview of the Prusti project. We outline its main design goals, illustrate examples of its use, and discuss important outcomes from the perspectives of a user, a verification expert, and a tool developer.ISSN:0302-9743ISSN:1611-334