View: session overviewtalk overview

13:00 | Monadic Decomposition in Integer Linear Arithmetic ABSTRACT. Monadic decomposability is a notion of variable independence, which asks whether a given formula in a first-order theory is expressible as a boolean combination of monadic predicates in the theory. Recently, Veanes et al. showed the usefulness of monadic decomposability in the context of SMT (i.e. input formula is quantifier-free), and found various interesting applications including string analysis. Despite these, checking monadic decomposability is undecidable in general. Decidability for certain theories is known (e.g. Presburger Arithmetic, Tarski's Real Closed Field), but there are very few results regarding their computational complexity. In this paper, we study monadic decomposability of integer linear arithmetic in the setting of SMT. We show that this decision problem is coNP-complete and, when monadically decomposable, a formula admits a decomposition of exponential size in the worst case. We provide a new application of our results to string constraint solving with length constraints. We then extend our results to variadic decomposability, where predicates could admit multiple free variables (in contrast to monadic decomposability). We provide an application to quantifier elimination in integer linear arithmetic where the variables in a block of quantifiers, if independent, could be eliminated with an exponential (instead of the standard double exponential) blow-up. |

13:30 | An SMT Theory of Fixed-Point Arithmetic ABSTRACT. Fixed-point arithmetic is a popular alternative to floating-point arithmetic on embedded systems. Existing work on the verification of fixed-point programs relies on custom formalizations of fixed-point arithmetic, which makes it hard to compare the described techniques or reuse the implementations. In this paper, we address this issue by proposing and formalizing an SMT theory of fixed-point arithmetic. We present an intuitive yet comprehensive syntax of the fixed-point theory, and provide formal semantics for it based on rational arithmetic. We also describe two decision procedures for this theory: one based on the theory of bit-vectors and the other on the theory of reals. We implement the two decision procedures, and evaluate our implementations using existing mature SMT solvers on a benchmark suite we created. Finally, we perform a case study of using the theory we propose to verify properties of quantized neural networks. |

14:00 | Scalable Algorithms for Abduction via Enumerative Syntax-Guided Synthesis PRESENTER: Haniel Barbosa ABSTRACT. The abduction problem asks whether there exists a predicate that is consistent with a given set of axioms that when added to these axioms suffices to entail a goal. We propose an approach for solving the abduction problem that is based on syntax-guided enumeration in the Satisfiability Modulo Theories (SMT) solver CVC4. For scalability, we use a novel algorithm that incrementally constructs a solution in disjunctive normal form that is built from enumerated predicates. The algorithm can be configured to generate progressively weaker and simpler solutions over the course of a run of the algorithm. Our approach is fully general and can be applied over any background logic that is handled by the underlying SMT solver in our approach. Our experiments show our approach compares favorably with other tools for abductive reasoning. |

14:30 | Removing Algebraic Data Types from Constrained Horn Clauses Using Difference Predicates ABSTRACT. We address the problem of proving the satisfiability of Constrained Horn Clauses (CHCs) with Algebraic Data Types (ADTs), such as lists and trees. We propose a technique that transforms sets of CHCs with ADTs into CHCs where predicates are defined over basic types, such as integers and booleans, only. We show that if the set of transformed clauses is satisfiable, then so is the set of the original clauses. Thus, our technique avoids the explicit use of inductive proof rules during satisfiability proofs. The main extension over previous techniques is that the transformation automatically generates new predicates corresponding to the lemmata that are often needed by inductive proofs. By an experimental evaluation, we show that our approach is competitive with respect to techniques that extend CHC solving with induction. |

13:00 | Efficient Verified Implementation of Introsort and Pdqsort ABSTRACT. Sorting algorithms are an important part of most standard libraries, and both, their correctness and efficiency is crucial for many applications. As generic sorting algorithm, the GNU C++ Standard Library implements the Introsort algorithm, a combination of quicksort, heapsort, and insertion sort. The Boost C++ library implements Pdqsort, an extension of Introsort that achieves linear runtime on inputs with certain patterns. We verify Introsort and Pdqsort in the Isabelle LLVM verification framework, including most of the optimizations from the GNU and Boost implementations. On an extensive benchmark set, our verified algorithms perform on par with the originals. |

13:30 | A Fast Verified Liveness Analysis in SSA form ABSTRACT. Liveness analysis is a standard compiler analysis, enabling several optimizations such as deadcode elimination. The SSA form is a popular compiler intermediate language allowing for simple and fast optimizations. Boissinot et al. designed a fast liveness analysis by combining the specific properties of SSA with graph-theoretic ideas such as depth-first search and dominance. We formalize their approach in the Coq proof assistant, inside the CompCertSSA verified C compiler. We also compare experimentally this approach on CompCert's benchmarks with respect to the classic dataflow-based liveness analysis, and observe performance gains. |

14:00 | Verified Approximation Algorithms ABSTRACT. We present the first formal verification of approximation algorithms for NP-complete optimization problems: vertex cover, independent set, load balancing, and bin packing. In the process we uncover incompletenesses in existing proofs and improve the approximation ratio in one case. |

14:30 | Verification of Closest Pair of Points Algorithms PRESENTER: Martin Rau ABSTRACT. We verify two related divide-and-conquer algorithms solving one of the fundamental problems in Computational Geometry, the Closest Pair of Points problem. Using the interactive theorem prover Isabelle/HOL, we prove functional correctness and the optimal running time of O(n log n) of the algorithms. We generate executable code which is empirically competitive with handwritten reference implementations. |

15:15 | Domain-Specific Reasoning with Satisfiability Modulo Theories |

16:30 | Termination Competition PRESENTER: Florian Frohn |

16:45 | The CADE ATP System Competition Presentation |

17:00 | A Polymorphic Vampire (short paper) ABSTRACT. We have modified the Vampire theorem prover to support rank-1 polymorphism. In this paper we discuss the changes required to enable this and compare the performance of polymorphic Vampire against other polymorphic provers. We also compare its performance on monomorphic problems against standard Vampire. Finally, we discuss how polymorphism can be used to support theory reasoning and present results related to this. |

17:15 | Implementing superposition in iProver (system description) ABSTRACT. iProver is a saturation theorem prover for first-order logic with equality, which is originally based on an instantiation calculus, Inst-Gen. In this paper we describe an extension of iProver with the superposition calculus. We have developed a flexible simplification setup that subsumes and generalises common architectures such as Discount or Otter. This also includes the concept of "immediate simplification", wherein newly derived clauses are more aggressively simplified among themselves, which can make the given clause redundant and thus its children discarded, and the concept of "light normalisation", wherein ground unit equations are stored in an interreduced TRS which is then used to simplify new clauses. We have also added support for associative-commutative theories (AC), namely by deletion of AC-joinable clauses, semantic detection of AC axioms, and preprocessing normalisation. |

17:30 | Teaching Automated Theorem Proving by Example: PyRes 1.2 (system description) ABSTRACT. PyRes is a complete theorem prover for first-order logic. It is not designed for high performance, but to clearly demonstrate the core concepts of a saturating theorem prover. The system is written in extensively commented Python, explaining data structures, algorithms, and many of the underlying theoretical concepts. The prover implements binary resolution with factoring and optional negative literal selection. Equality is handled by adding the basic axioms of equality. PyRes uses the given-clause algorithm, optionally controlled by weight- and age evaluations for clause selection. The prover can read TPTP CNF/FOF input files and produces TPTP/TSTP proof objects. Evaluation shows, as expected, mediocre performance compared to modern high-performance systems, with relatively better performance for problems without equality. However, the system seems to be sound and complete in practice. |

17:45 | The Imandra Automated Reasoning System (system description) ABSTRACT. We describe Imandra, a modern computational logic theorem prover designed to bridge the gap between decision procedures such as SMT, semi-automatic inductive provers of the Boyer-Moore family like ACL2, and interactive proof assistants for typed higher-order logics. Imandra's logic is computational, based on a pure subset of OCaml in which all functions are terminating, with restrictions on types and higher-order functions that allow conjectures to be translated into multi-sorted first-order logic with theories, including arithmetic and datatypes. Imandra has novel features supporting large-scale industrial applications, including a seamless integration of bounded and unbounded verification, first-class computable counterexamples, efficiently executable models and a cloud-native architecture supporting live multiuser collaboration. % The core reasoning mechanisms of Imandra are \begin{inparaenum}[(i)] \item a semi-complete procedure for finding models of formulas in the logic mentioned above, centered around the lazy expansion of recursive functions, \item an inductive waterfall and simplifier which ``lifts'' many Boyer-Moore ideas to our typed higher-order setting. \end{inparaenum} % These mechanisms are tightly integrated and subject to many forms of user control. Imandra's user interfaces include an interactive toplevel, Jupyter notebooks and asynchronous document-based verification (in the spirit of Isabelle's Prover IDE) with VS Code. |