# Programme

**PROGRAMME DESCRIPTION**

Artificial Intelligence techniques have become an integral part of our lives, being applied with tremendous success both in the private and academic sectors. It is unquestionable that we are witnessing the emergence of a new, fundamental tool that is starting to revolutionise how science is done. Mathematics and Theoretical Physics require a qualitatively different kind of AI tools, focused not only on results, but also on uncovering the mechanisms underlying them for the formulation of mathematically precise conjectures that can subsequently be approached using rigorous methods.

Many problems in Theoretical Physics, Algebraic Geometry and related areas in Pure Mathematics are beginning to develop fruitful interactions with Machine Learning. In parallel to these developments, establishing a firm theoretical understanding of Machine Learning will require methods from both Algebraic Geometry and Theoretical Physics, such as Quantum Field Theory. Promoting this fruitful interdisciplinary dialogue is the main purpose of the School.

The primary audience for the course consists of PhD students and young researchers working on Algebraic Geometry, Differential Geometry and Topology questions in String Theory, as well as Pure Mathematics. All courses will have minimum prerequisites, which will be soon detailed on this webpage. Each day of the programme will include 2-3 lectures in the morning, followed by tutorials in the afternoons. The tutorial sessions will focus on working out in detail the examples presented in the lectures, so as to build concrete experience with the material covered in lectures.

Descriptions of the courses are given below, together with reading lists and recommendations for installing software that will be used in the school. The reading list is not a mandatory pre-requisite, but it can significantly accelerate your learning curve.

**Topic 1: ML basics **(Fabian Ruehle)

I will start by introducing the simplest type of neural networks, multi-layer feed-forward neural networks, and how they are trained in the context of supervised or semi-supervised ML via backpropagation. In the second part, I will introduce the transformer architecture (the "T" in GPT), which revolutionised the field of natural language processing. In the tutorials, we will implement a simple neural network that recognises hand-written digits using TensorFlow in Python.

**Reading:**

- Data science applications to string theory https://www.sciencedirect.com/science/article/pii/S0370157319303072, Chapters 1-4
- Attention is all you need https://arxiv.org/abs/1706.03762

**Software: **you should have access to python with pytorch, tensorflow, matplotlib, numpy, and Jupyter notebook installed (see the instructions below)

**Topic 2: Knot Theory and Reinforcement Learning **(Fabian Ruehle)

In the first lecture, I will introduce Reinforcement Learning (RL) and how it can be used to obtain verifiable results in mathematics. In the second lecture, I will explain how to apply this to problems in knot theory, involving the question of whether a knot is trivial or not, and whether it has a property called sliceness, which is important for the smooth Poincare conjecture in four dimensions. In the tutorials, we will implement an RL algorithm that learns how to solve a maze using the chainerrl library in Python.

**Reading:**

- Data science applications to string theory https://www.sciencedirect.com/science/article/pii/S0370157319303072, Chapter 8
- Learning to unknot https://arxiv.org/pdf/2010.16263.pdf
- Searching for ribbons with Machine Learning https://arxiv.org/pdf/2304.09304.pdf

**Software: **chainerrl package

**Topic 3: String Theory Compactifications, Calabi-Yau Manifolds and Ricci-flat Metrics** (Lara Anderson, James Gray, Magdalena Larfors)

These lectures will explore applications of Machine Learning to understanding the geometry of Calabi-Yau manifolds. The series will begin with an overview of the necessary geometric background. We will then go on to describe some conventional techniques which have historically been used to approximate the Ricci-flat metric on Calabi-Yau threefolds. Next, we will describe the application of Machine Learning in this context. We will show how such techniques are used to both augment and replace the previously existing methods, allowing us to obtain qualitatively different results.

In the tutorials associated to this series, exercises will be provided to help understand some of the mathematical background. In addition, the students will be given the opportunity to explore applications of Machine Learning which are simplified analogs of the techniques which will be applied to Calabi-Yau manifolds. Computational exercises in the actual geometric setting of interest will then be set using Packages which have been developed in the literature.

**Reading:** Here is some initial reading that the students can take a look at ahead of time. We emphasise that, while it would be useful to look through particularly the geometric background beforehand, it is not necessary to read all of this material before the course starts. In particular, the references in the second and third headings below are all technical research papers - so approach with caution if you want to have a look before the lectures!

**Geometry/Physics Background**

- Candelas' lecture notes

- https://arxiv.org/pdf/1804.
08792.pdf

**Conventional Methods**

- https://arxiv.org/abs/0908.
2635 - https://arxiv.org/pdf/hep-th/
0612075.pdf & https://arxiv.org/pdf/1004.4399.pdf

**Machine Learning Methods**

- https://arxiv.org/abs/2012.
04797 - https://arxiv.org/abs/2012.
04656 - https://arxiv.org/abs/2205.
13408 - https://arxiv.org/abs/2211.
12520

**Topic 4: Heuristic Search Techniques: Genetic Algorithms and Quantum Annealing **(Steve Abel)

The advent of the string landscape has stimulated interest in heuristic search methods which are based on processes that occur in nature. Indeed nature evidently has to cope with far larger search spaces than those that are encountered in any string theory. For example the possible configurations of DNA are infeasibly large and yet nature is able to find solutions to problems very easily — often several times as happens in so-called “convergent evolution”. Likewise the number of spin configurations in a lattice grows exponentially with lattice size. And yet phase transitions to the single true ground state occur without issue. This three lecture course introduces some of the heuristic search methods that have been inspired by these naturally occurring phenomena.

The first method is the Genetic Algorithm (GA). In this approach, one mimics natural selection by inserting a population of “creatures” into the search space, whose DNA (usually referred to as the genotype) corresponds to different parameter choices. The creatures are then allowed to breed, and this over generations leads to a facsimile of evolution, with the aim that the population evolves to the desired solution.

The second method that will be discussed is annealing, more specifically Quantum Annealing although much of the discussion can apply to both Quantum and Thermal annealing. Quantum Annealing is different from the kind of quantum computing you may have encountered before. Unlike more standard (gate-model) quantum computing it is more akin to simulated annealing, and works by the dissipative evolution of an Ising spin Hamiltonian (i.e. a system of coupled qubits) in order to find the ground state. Therefore the crux of solving any problem lies in formulating its solution as the minimum of an Ising model.

**Outline**

Lecture 1: Introduction to Genetic Algorithms and example problems.

Tutorial 1: Solving a simple (to express) problem using GAs

Lecture 2: Introduction to Quantum Annealing in both physical quantum annealers, and on gate based quantum computers.

Tutorial 2: Solving a simple (to express) problem using Quantum Annealing.

Lecture 3: Overview of applications to string problems.

**Prerequisites**: Python, C or C++ (or Fortran if you insist).

**Resources. ****GAs:** Unlike quantum annealing, GA’s have some good textbooks.

https://books.google.co.uk/books/about/Genetic_Algorithms.html?id=6gzS07Sv9hoC&redir_esc=y

The following articles also appear on the archives if you find that you are blocked by a paywall.

- GA’s in model parameter searches: https://iopscience.iop.org/article/10.1088/1126-6708/2004/07/069
- GA’s in strings: https://link.springer.com/article/10.1007/JHEP08(2014)010, https://onlinelibrary.wiley.com/doi/10.1002/prop.202200034
- The importance of hybrid approaches: https://arxiv.org/pdf/2005.11329.pdf

Available GA software (although you may find it faster to write your own rather than try to figure out what someone else’s code is doing):

- PIKAIA (in Fortran but it can be beaten up until it works with C or C++. I never succeeded in calling it from Python) https://www.hao.ucar.edu/modeling/pikaia/pikaia.php
- PyGAD: works in https://pypi.org/project/pygad/ A nice introduction to it is at https://towardsdatascience.com/genetic-algorithm-implementation-in-python-5ab67bb124a6

**Quantum Annealing:** Quantum annealing introduction and practical starting point including information on D-wave software installation (note also includes simulated annealing modules):

- D-Wave: what is quantum annealing?
- QIBO quantum computing and (orthogonal) quantum annealing software: https://qibo.science

**Topic 5: Classification of Fano Varieties **(Alexander Kasprzyk)

Fano varieties are a fundamental class of geometric spaces studied in Algebraic Geometry. They are, in the precise sense of the Minimal Model Programme, "atomic pieces" from which other varieties can be understood. Fano varieties also play an essential role in string theory: through their anticanonical sections they provide one of the main constructions of Calabi--Yau manifolds, which give geometric models of spacetime. Despite this fundamental importance, their classification remains largely mysterious. Recent progress on the classification of Fano varieties has been made by borrowing ideas from Mirror Symmetry. This approach encodes the geometry of a Fano variety as a period sequence: an infinite sequence of integers. Examples of period sequences can be systematically generated via distributed computations on HPC systems. These period sequences can then be studied using techniques from Data Science. In particular, Machine Learning experiments are beginning to expose a wealth of previously unsuspected geometric structure hidden in this data. Although rigorous mathematical explanations for this structure is beyond our current abilities, never the less Machine Learning results allow us to form conjectures and develop insights that will shape the direction of future research. These talks will explain this mathematical background, keeping all the material at a suitably accessible level. I will then explain how we have used Machine Learning to explore the data.

**Reading:**

- https://arxiv.org/abs/2211.10069 "Computation and data in the classification of Fano varieties" -- high-level overview of how data is helping sketch the landscape of Fano varieties
- https://arxiv.org/abs/1212.1722 "Mirror symmetry and Fano manifolds" -- the original paper describing the approach to Fano classification via Mirror Symmetry; quite technical but hopefully gives a good sense of the underlying mathematics
- https://arxiv.org/abs/2207.07717 "Machine learning the dimension of a polytope" -- not directly on the same topic, but in fact there is more of an overlap between the mathematics that is immediately obvious, and this gives a taste for how ML can inform our mathematical understanding

Some unpublished results and datasets will be shared with the participants at the first lecture.

**Software: **standar Python packages: sklearn, matplotlib, nympy.

**Guest Lecture 1: Normalising Flows for Lattice Field Theories **(Miranda Cheng)

Abstract: Normalising flows are powerful generative models in machine learning. Lattice field theories are indispensable as a computation framework for non-perturbative quantum field theories. In lattice field theory one needs to generative sample field configurations in order to compute physical observables. In this lecture I will survey the different normalising flow architectures and discuss how they can be exploited in lattice field theory computations.

**Guest Lecture 2: ****The unknotting number, hard unknot diagrams, and Reinforcement Learning **(Andras Juhasz)

Abstract: We have developed a Reinforcement Learning agent based on the IMPALA architecture that often finds minimal unknotting trajectories for a knot diagram up to 200 crossings. We have used this to determine the unknotting number of 57k knots. We then took diagrams of connected sums of such knots with oppositely signed signatures, where the summands were overlaid. The agent has found unknotting trajectories involving several crossing changes that result in hyperbolic knots. Based on this, we have shown that, given knots K and K' that are not 2-bridge, there is a diagram of their connected sum and u(K) + u(K') unknotting crossings such that changing any one of them results in a prime knot. As a by-product, we have obtained a dataset of 2.6 million distinct hard unknot diagrams; most of them under 35 crossings. Assuming the additivity of the unknotting number, we can determine the unknotting number of 43 at most 12-crossing knots for which the unknotting number is unknown. This is joint work with Taylor Applebaum, Sam Blackwell, Alex Davies, Thomas Edlich, Marc Lackenby, Nenad Tomasev, and Daniel Zheng.

**Software installation (python with tensorflow, matplotlib, numpy, chainerrl and Jupyter notebook)**

__Option 1:__ Local software installation (python with pytorch, tensorflow, matplotlib, numpy, chainerrl and Jupyter notebook)

**For Linux and Mac users:**

1.) Open a terminal:

- On Linux press: Ctrl + Alt + T
- On Mac press: command+space, type terminal,press enter

2.) Create a virtual environment: execute the command

python3 -m venv ~/tutorialsvenv

3.) Activate the environment (needs to be done every time):

source ~/tutorialsvenv/bin/activate

4.) Update the package manager (needs to be done only once):

pip install --upgrade pip

5.) Install the required packages (needs to be done only once):

pip install numpy matplotlib chainerrl jupyter notebook torch

6.) Install tensorflow (needs to be done only once):

- On Linux and Macs with Intel chips: pip install tensorflow
- On Macs with the new arm chip (M1, M2): pip install tensorflow-metal

7.) Open jupyter in your default browser:

jupyter notebook

**For Windows users:**

1.) Open a terminal: Press: Windows key + x, select Windows Terminal (Admin)

2.) Download python (skip if you already have python)

winget install python.python.3.9

3.) Update the package manager (needs to be done only once):

pip install --upgrade pip

4.) Install package for virtual environment (needs to be done only once):

pip install virtualenv

5.) Create a virtual environment: execute the command

virtualenv --python C:\Path\To\Python\python.exe tutorialsvenv

6.) Activate the environment (needs to be done every time):

.\tutorialsvenv\Scripts\activate

7.) Install the required packages (needs to be done only once):

pip install numpy matplotlib chainerrl jupyter notebook tensorflow torch

8.) Open jupyter in your default browser:

jupyter notebook

**Option 2: Google Colab (python online)**

This option requires a google account. Once you have one setup, follow the steps at https://colab.research.google.com/.

The interface is essentially a python notebook, and you can install the required packages with

pip install numpy matplotlib chainerrl tensorflow torch

**For Quantum Annealing**

pip install dwave-neal

check if dwave-neal has been installed by running in Jupiter the following code

import neal

**For the tutorials on Calabi-Yau metrics**

The notebook for the tutorial is available at: https://github.com/edhirst/OxfordCYTutorial/tree/main

For the second tutorial on Friday install cymetric: