  We present Aeneas, a new verification toolchain for Rust programs based on a
lightweight functional translation. We leverage Rust's rich region-based type
system to eliminate memory reasoning for many Rust programs, as long as they do
not rely on interior mutability or unsafe code. Doing so, we relieve the proof
engineer of the burden of memory-based reasoning, allowing them to instead
focus on functional properties of their code.
  Our first contribution is a new approach to borrows and controlled aliasing.
We propose a pure, functional semantics for LLBC, a Low-Level Borrow Calculus
that captures a large subset of Rust programs. Our semantics is value-based,
meaning there is no notion of memory, addresses or pointer arithmetic. Our
semantics is also ownership-centric, meaning that we enforce soundness of
borrows via a semantic criterion based on loans rather than through a syntactic
type-based lifetime discipline. We claim that our semantics captures the
essence of the borrow mechanism rather than its current implementation in the
Rust compiler.
  Our second contribution is a translation from LLBC to a pure lambda-calculus.
This allows the user to reason about the original Rust program through the
theorem prover of their choice. To deal with the well-known technical
difficulty of terminating a borrow, we rely on a novel approach, in which we
approximate the borrow graph in the presence of function calls. This in turn
allows us to perform the translation using a new technical device called
backward functions.
  We implement our toolchain in a mixture of Rust and OCaml. Our evaluation
shows significant gains of verification productivity for the programmer.
  Rust goes to great lengths to enforce static control of aliasing; the proof
engineer should not waste any time on memory reasoning when so much already
comes "for free"!
