Andrea Lattuada

Andrea Lattuada

Auto-generated profile, based on publicly available information

Andrea Lattuada

MPI-SWS, Saarbrücken, Germany

Research Focus & Metrics

Academic Career Length

5Years (2022-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
6 April 2023 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
ALAndrea Lattuada
Andrea Lattuada
THTravis Hance
Travis Hance
CCChanhee Cho
Chanhee Cho
MBMatthias Brun
Matthias Brun
ISIsitha Subasinghe
Isitha Subasinghe
CHChris Hawblitzel
Chris Hawblitzel
The Rust programming language provides a powerful type system that checks linearity and borrowing, allowing code to safely manipulate memory without garbage collection and making Rust ideal for developing low-level, high-assurance systems. For such systems, formal verification can be useful to prove functional correctness properties beyond type safety. This paper presents Verus, an SMT-based tool for formally verifying Rust programs. With Verus, programmers express proofs and specifications using the Rust language, allowing proofs to take advantage of Rust's linear types and borrow checking. We show how this allows proofs to manipulate linearly typed permissions that let Rust code safely manipulate memory, pointers, and concurrent resources. Verus organizes proofs and specifications using a novel mode system that distinguishes specifications, which are not checked for linearity and borrowing, from executable code and proofs, which are checked for linearity and borrowing. We formalize Verus' linearity, borrowing, and modes in a small lambda calculus, for which we prove type safety and termination of specifications and proofs. We demonstrate Verus on a series of examples, including pointer-manipulating code (an xor-based doubly linked list), code with interior mutability, and concurrent code.

4 November 2024
Verified
Conference Paper
Open access
ALAndrea Lattuada
Andrea Lattuada
THTravis Hance
Travis Hance
JBJay Bosamiya
Jay Bosamiya
MBMatthias Brun
Matthias Brun
CCChanhee Cho
Chanhee Cho
BPBryan Parno
Bryan Parno
Formal verification is a promising approach to eliminate bugs at compile time, before they ship. Indeed, our community has verified a wide variety of system software. However, much of this success has required heroic developer effort, relied on bespoke logics for individual domains, or sacrificed expressiveness for powerful proof automation. Building on prior work on Verus, we aim to enable faster, cheaper verification of rich properties for realistic systems. We do so by integrating and optimizing the best choices from prior systems, tuning our design to overcome barriers encountered in those systems, and introducing novel techniques. We evaluate Verus's effectiveness with a wide variety of case-study systems, including distributed systems, an OS page table, a library for NUMA-aware concurrent data structure replication, a crash-safe storage system, and a concurrent memory allocator, together comprising 6.1K lines of implementation and 31K lines of proof. Verus verifies code 3--61× faster and with less effort than the state of the art. Our results suggest that Verus offers a platform for exploring the next frontiers in system-verification research. Because Verus builds on Rust, Verus is also positioned for wider use in production by developers who have already adopted Rust in the pursuit of more robust systems.

29 April 2022 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
JLJialin Li
Jialin Li
ALAndrea Lattuada
Andrea Lattuada
YZYi Zhou
Yi Zhou
JCJonathan Cameron
Jonathan Cameron
JHJon Howell
Jon Howell
CHChris Hawblitzel
Chris Hawblitzel
Reasoning about memory aliasing and mutation in software verification is a hard problem. This is especially true for systems using SMT-based automated theorem provers. Memory reasoning in SMT verification typically requires a nontrivial amount of manual effort to specify heap invariants, as well as extensive alias reasoning from the SMT solver. In this paper, we present a hybrid approach that combines linear types with SMT-based verification for memory reasoning. We integrate linear types into Dafny, a verification language with an SMT backend, and show that the two approaches complement each other. By separating memory reasoning from verification conditions, linear types reduce the SMT solving time. At the same time, the expressiveness of SMT queries extends the flexibility of the linear type system. In particular, it allows our linear type system to easily and correctly mix linear and nonlinear data in novel ways, encapsulating linear data inside nonlinear data and vice-versa. We formalize the core of our extensions, prove soundness, and provide algorithms for linear type checking. We evaluate our approach by converting the implementation of a verified storage system (about 24K lines of code and proof) written in Dafny, to use our extended Dafny. The resulting system uses linear types for 91% of the code and SMT-based heap reasoning for the remaining 9%. We show that the converted system has 28% fewer lines of proofs and 30% shorter verification time overall. We discuss the development overhead in the original system due to SMT-based heap reasoning and highlight the improved developer experience when using linear types.

12 October 2025
Verified
Conference Paper
Open access
TKTom Kuchler
Tom Kuchler
PLPinghe Li
Pinghe Li
YZYazhuo Zhang
Yazhuo Zhang
LCLazar Cvetković
Lazar Cvetković
BGBoris Goranov
Boris Goranov
AKAna Klimovic
Ana Klimovic

22 June 2023
Verified
Conference Paper
Open access
MBMatthias Brun
Matthias Brun
RAReto Achermann
Reto Achermann
TCTej Chajed
Tej Chajed
JHJon Howell
Jon Howell
GZGerd Zellweger
Gerd Zellweger
ALAndrea Lattuada
Andrea Lattuada
Verified systems software has generally had to assume the correctness of the operating system and its provided services (like networking and the file system). Even though there exist verified operating systems and file systems, the specifications for these components do not compose with applications to produce a fully verified high-performance software stack. In this position paper, we lay out our vision for what it would look like to have a verified OS with verified applications, all with good multi-core performance. We've explored a part of the verification by proving a page table correct already, but the larger goal is to lay out a vision for an ambitious project that supports an application verified from its high-level specification down to the hardware.

10 June 2025 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
SSSimon Spies
Simon Spies
NMNiklas Mück
Niklas Mück
HZHaoyi Zeng
Haoyi Zeng
MSMichael Sammler
Michael Sammler
ALAndrea Lattuada
Andrea Lattuada
DDDerek Dreyer
Derek Dreyer
The separation logic framework Iris has been built on the premise that all assertions are stable , meaning they unconditionally enjoy the famous frame rule . This gives Iris—and the numerous program logics that build on it—very modular reasoning principles. But stability also comes at a cost. It excludes a core feature of the Viper verifier family, heap-dependent expression assertions , which lift program expressions to the assertion level in order to reduce redundancy between code and specifications and better facilitate SMT-based automation. In this paper, we bring heap-dependent expression assertions to Iris with Daenerys . To do so, we must first revisit the very core of Iris, extending it with a new form of unstable resources (and adapting the frame rule accordingly). On top, we then build a program logic with heap-dependent expression assertions and lay the foundations for connecting Iris to SMT solvers. We apply Daenerys to several case studies, including some that go beyond what Viper and Iris can do individually and others that benefit from the connection to SMT.