Reo is a graphical language for programming coordination protocols, i.e., the patterns of interaction allowed between components. One of the main advantages of using Reo to coordinate your components is that you can treat the choreography as part of your code, rather than having to sprinkle little snippets of code in your program and hope that, together, they implement your intention. Protocols implemented in Reo can be compiled to, for example, Java code, and used in conjunction with hand-written code. What's more, Reo allows for protocols to be optimised to more efficient (but equivalent) representations, thus reducing the overhead of coordinating interaction.

Recently, programming languages have started to support asynchronous I/O; in this paradigm, tasks (coroutines) yield control back to an event loop whenever they perform a blocking I/O action, such as reading from a file or writing to a network socket. The program can then continue with some other task, thus preventing the overhead of a context switch; when the original blocking I/O action completes, the task is scheduled for resumption. This paradigm can result in impressive speedups for heavily I/O-bound programs such as web servers.

Coroutines, like components, may interact with one another; the need to coordinate their interaction then arises. In this project, your task would be to attempt a Reo implementation for coordination between tasks in asynchronous Python and benchmark this against handwritten code. Challenges include familiarising yourself with Reo and asynchronous programming, as well as the design of a friendly API for using Reo in Python.

SageMath is a Python-based free and open-source mathematics software system similar to Mathematica. Built on top of NumPy, SciPy, SymPy, and the like, it can support a number of non-trivial mathematical tasks through a well-designed interface. The cryptography research community, for instance, uses the interface provided by SageMath for prototyping and breaking ciphers.

SageMath also contains a library supporting the manipulation of finite automata that, although nontrivial, is not as feature-rich as other parts. For instance, this library is missing support for variations on finite automata such as automata on guarded strings, alternating automata, or algebraic equivalents of finite automata in the form of syntactic monoids, to name a few. Algorithmically, support for state-of-the-art algorithms to check equivalence of automata by means of bisimulation (up-to), or to compute the atoms of the automaton is missing.

In this project, you will familiarise yourself with well-known constructions around automata, and then work to implement support for some of these. The end goal is to contribute the resulting source code back to SageMath, which will help students and researchers around the world to quickly prototype their own algorithms. Challenges include a good integration of these algorithms in the existing code of SageMath, documenting your code, and designing a friendly API.