# Projects for Students

We offer projects suitable for

- bachelor and master thesis
- bachelor and master practical course
- interdisciplinary project
- paid work as “studentische Hilfskraft” (HiWi) with flexible conditions

The following projects are currently available:

## Analytic Number Theory

There is an ongoing effort to formalise Tom Apostol’s classic textbook on Analytic Number Theory. Most of the core content has already been formalised, but there are some chapters that have been left out completely, e.g. Number Partitions.

## Verification of approximation algorithms for graphs

Many basic graph theoretic problems are either NP-hard or are not known to be solved in better than impractical polynomial times. This makes solving those problems prohibitive if not impossible for real-world graphs. Approximation algorithms circumvent that by using less resources than exact algorithms, at the expense of providing only approximate solutions. In this project the student would formally verify that 1) the approximate solutions of those algorithms meet a certain quality guarantee and 2) the upper bounds on their runtimes are correct. Particularly interesting algorithms are for computing lower-bounds on (directed) graph diameters and approximate solutions to the All-Pairs-Shortest-Paths problem. Some of those algorithms are deterministic, and others have elements of randomness in them. A randomised algorithm would be more interesting from a verification perspective.

## Automatic Laurent Series Expansions

Sufficiently nice complex-valued functions admit Laurent series expansions, which can be computed symbolically. This is an important feature in Computer Algebra Systems like Mathematica that can be used to e.g. compute limits and complex residues. In this Master’s thesis project, a procedure is developed that computes such Laurent series inside the proof assistant Isabelle/HOL to aid the user by automatically proving limits, residues, and reasoning about poles.

## Clone Detection in Isabelle Theories

Duplicate code segments, or “clones,” typically arise when developers copy & paste existing code to form the basis of new code. While occasionally helpful, clones can complicate maintenance drastically, and often indicate a code quality issues. The goal of this project is to develop a tool to detect clones in formal Isabelle theories. The tool should be developed as a frontend to an existing clone detection framework, such as Moss or JCCD.

## Efficient Algorithms and Data Structures in Isabelle/HOL

The goal of this project is to formalize some algorithm (e.g. the blossom algorithm for maximal cardinality matching, algorithm for closest pair of points,…) or efficient data structure in Isabelle/HOL and use refinement techniques to refine the algorithm down to efficiently executable code.

## Numerical Proof Procedures in Isabelle/HOL

The Isabelle theorem prover can prove variable-free arithmetic statements automatically, for example arctan 1.5 < 1. The proof procedure uses Taylor polynomials and interval arithmetic. It should be extended to support more operations or make use of IEEE floating point numbers.

## Formalising graph theoretic results with combinatorial optimisation applications

Combinatorial optimisation algorithms and proofs of their correctness depend, in many cases, on graph theoretic results. In this project the student would formalise such graph theoretic results in Isabelle/HOL. The formalisation would build on a theory of undirected graphs developed in the context of verifying Edmond’s blossom shrinking algorithm.

## Group Theory

The purpose of this project is to add various missing bits of group theory to HOL-Algebra, with a particular focus on finite groups.

## Extending the theory of line integrals or generalising it to surface integrals

Line integrals are a basic concept of integration that evolved in the context of physics, but currently has many applications. An Isabelle/HOL theory of line integrals was developed as a part of formalising Green’s theorem. In this project the student would work on extending the existing theory of line integrals by proving more of their properties, with a special focus on practically useful properties of them, like evaluation of different line integrals. A second possibility is developing a theory of surface integrals, which could be seen as a generalisation of the existing theory of line integrals.

## A Linter for Isabelle

In this project, the student should implement a linter for Isabelle [5] in Isabelle/Scala. A linter is a program that checks the source code for patterns that are undesirable. Undesirable patterns in Isabelle could be automated proofs that are prone to break after making small changes or more trivial things such as incorrect indentation with respect to some style guide. The linter should provide an interface to define lints, switching lints on and off both globally and locally, and a way to report the lints both in a human and a machine-readable format.

## Primality Testing

There are many different tests to determine if a natural number is prime. Most of these are *probabilistic* and always recognise a prime number as prime, but, with some probability, also mistakenly classify composites as primes. Some of these tests (Fermat, Miller–Rabin, Solovay–Strassen) are already formalised in Isabelle.

## Query optimization for databases

Queries to relational databases frequently touch more than a hundred relations at a time. When executing those queries the order of joins between those relations is of utmost importance to the performance of the query. The goal of this project is to formalise the basis of query optimisation, i.e. query graphs and join trees. After that, one can proceed to formalise query optimisation algorithms such as the IKKBZ algorithm or dynamic programming algorithms.

## Specialised Mathematical Tactics and Simprocs

The goal is to implement various additional tactics and/or simplification procedures (‘simprocs’) to simplify/expand certain mathematical terms that are difficult to simplify using simp rules (e.g.: proving/disproving/rewriting statements like “4/3 ∈ ℤ”, k-th integer root and k-th power testing ,…). Some of these can be done using externally-computed certificates (e.g.: primality: Pratt certificate, prime power: prime factor (with Pratt certificate) and multiplicity, compositeness: two non-trivial factors, …).

## Theorem Dependency Mining

The theories of the Isabelle Archive of Formal Proofs (AFP) form a large dependency graph. This projects goal is to utilize graph mining techniques in order to identify useful patterns in theorem dependencies, such as lemmas that are frequently used together in proofs.

## Automatic Definition of Running Time Functions

The aim of this project is to automate the definition of ``running time functions’’, i.e. functions that express the complexity of another function. The automation should translate the definition of some function `f`

in a simple functional language to an analogous function that computes the number of function calls `f`

makes.

## Verified planning under uncertainty (i.e. (PO)MDP planning)

AI planning is the discipline aiming at building agents (i.e. computer programs) that act to achieve a certain goal, given a declarative description of the environment and the actions available to it. In practical applications, like autonomous vehicles driving, it is not possible to model the exact effects of actions. Planning in settings with uncertainty has been explored in the areas of AI, control, and operations research. In those settings the environment is commonly modelled as a factored Markov decision process (MDP) or a partially observable MDP.

## Verified state space based classical planning

State space search is a successful technique to solve classical AI planning problems, i.e. deterministic problems with finite states. The main task of this project is to (partially) build a formally verified A* based planning algorithm.

## Testing with a verified oracle: using Symbolic Execution and Fuzzing

There is quite a large collection of formally verified algorithms in Isabelle. The idea of this project is to utilize these provably correct algorithms as oracles when testing real-world programs that implement the same algorithm. Symbolic Execution and Fuzzing could be used to generate new inputs used in this methodology.

## Isabelle/VSCode: Editor Improvements and Prover IDE integrations

The Isabelle/VSCode plugin already provides Isabelle functionality in the Visual Studio Code IDE, with some limitations. The aim of this project is to improve the integration as well as provide semantic IDE functionality for VSCode.