quantumjim / Quantum-Computation-course-Basel

Quantum Computation and Error Correction

This is a course at the University of Basel, given by Dr James Wootton of IBM Research.

This repository reflects the version of the course given in 2023. For the 2020, 2021 and 2022 version see here.

The lecture videos for this course are all on YouTube for you to view at any time.

Course Content

Quantum information theory is the basis of multiple emerging technologies, such as quantum computation and quantum crypotography. It allows us to understand how quantum effects in physical systems may be harnessed for new forms of information processing. The course will also feature some hands on experience with quantum technology, via the open-source Qiskit framework for quantum computing.

Course Text

The course will be based on the Qiskit textbook. Note that this link is to the Jupyter notebook source files of the textbook. The latest version of Qiskit learning materials can be found here.

Lectures

Most of the course will be done as a 'flipped classroom'. Lecture videos will be provided 1 week early. In-person sessions take place from 14:15-16:00 on Tuesdays. This will be used for questions from students, working together through exercises, and covering additional topics.

Below are links to the lecture videos for the lectures so far. For links to the corresponding sections of the textbook, see the video description.

• Lecture 1: The Atoms of Computation and What is Quantum and Python, Qiskit and Hello Qiskit

  • In-class lecture: The Unique Properties of Qubits
  • In-class exercise: Quantum Logic Gates

• Lecture 2: Representing Single Qubit States and Gates

  • In-class exercises: Playing with Paulis, More playing with Paulis

• Lecture 3: Multi qubit States and Circuit Identities

  • In-class lecture: Density matrices, partial trace and Schmidt decomposition.

• Lecture 4: Fun with matrices

• Lecture 5: Circuits and Universality

  • In-class lecture: Proof that Clifford + t is universal
  • In-class exercise: Real quantum computing

• Lecture 6: Basic Algorithms and Protocols

  • In-class lecture: Relative Entropy and Entanglement Sharing
  • In-class exercise: Trotters and Garbage

• Lecture 7: From the Fourier Transform to Shor's Algorithm

  • In-class lecture Quantum key distribution
  • In-class exercise: The order finding operator

• Lecture 8: Grover's Algorithm and why we can't yet run it

  • In-class lecture: Quantum noise and Stabilizer formalism

• Lecture 9: Introduction to QEC 1: The repetition code

  • In-class lecture: Decoding 1: Running Circuits and Interpreting Outputs

• Lecture 10: Introduction to QEC 2: The surface code

  • In-class lecture: Decoding 2: Correcting Errors

• Lecture 11: No video lecture

  • In-class lecture: Toric code and LDPC codes
  • In-class exercises: Shor code

• Lecture 12: No video lecture

  • In-class lecture: Decoding 3: Programming and Using a Matching Decoder

• Lecture 13: No video lecture

  • In-class lecture: Decoding 4: Programming HDRG Decoders

Exercises

In-Class Exercises

Exercises covered in class will be drawn from the big pile of all the exercises used in previous versions of this course.

Take-Home Exercises

Take-home exercises set on 17th Oct, 7th Nov and 28th Nov. There will be hints sessions at 16:15 on those dates. Solutions will be presented at 16:15 on 31st Oct, 21st Nov and 12th Dec.

• Exercise sheet 1: Set 17th Oct. Hint session and hand-in instructions at 16:15.

• Exercise sheet 2: Set 7th Nov. Hint session and hand-in instructions at 16:15 (on Zoom).

• Exercise sheet 3: Set 28th Nov. Hint session and hand-in instructions at 16:15.

Note: These exercises form 50% of your final grade

Final Project

As in previous years, we'll have a final project instead of a standard exam. The main aim of this is for you to demonstrate understanding of the topics in the course. The format is fairly free to allow you to do this in a way that suits you best. Collaboration will be fine. But everyone needs something unique to submit.

Note: This project forms 50% of your final grade

Important dates

You have until 15th January to hand-in your final projects (to me, by email). That gives you around 3 weeks after the hand-in of your final set of exercises (not including the Christmas break). You are expected to put a similar amount of time and effort in to the final project as you would put into two sets of exercises.

You have until 21st December to email me and ask for feedback on project ideas, and to give guidelines for what would be expected for them.

Project ideas

Below are examples of the different kinds of project you can choose from. Examples of existing work are given to give you and idea of what you can produce. A list of specific projects that you can do (for those of you that don't want to come up with your own) can be found at the end.

Write an explanation of a topic of your choice

You can write about one of the topics covered in the lectures, or about something that wasn't covered. You can include relevant example code in Qiskit, or you can avoid the programming and just have text and images

Examples

• Qiskit Textbook section on Phase Kickback.
• Qiskit Textbook section on Berstein-Vazirani.
• An attempt at a popular science article on quantum non-locality.

Make a game using quantum programming

Throughout the history of computing, people have been making simple games to help understand the new technology. Now we can do the same thing with quantum computing. I wrote a whole article on this idea, which you can find here.

Basically, reasons why we might make a quantum game are:

• To provide a simple and accessible example of a quantum program in action.
• To educate people about quantum computing.
• To start looking for ways in which quantum computing might actually be useful for games.

Remember: don't just use quantum for a random number generator!

Examples

• Hello Qiskit: a game that teaches quantum computing.
• Quantum Awesomeness: a game that gives insight into real devices (and featured in the NZZ).
• QPong: A game that implements the core game mechanic with a (simulation of).
• Q Avrai: using quantum computing for map generation.

Run benchmarks on prototype devices

You can access real quantum hardware at IBM Quantum, Quantum Inspire and other places. But how well do they actually work? Many people have run various different types of quantum circuit and analyzed the results to give some insight into this.

You can come up with your own method for benchmarking, or reproduce something that has already been done on a different device. The easiest way is to implement repetition codes using Qiskit-QEC. But since this package (hopefully) makes it easy, you'll need to try out more than just a single code on a single device

Examples

• Quantum Awesomeness: a game that gives insight into real devices (and featured in the NZZ).
• Decoherence of entangled states: A paper looking at decoherence in GHZ states.
• Repetition Codes: This uses Qiskit's old topological_codes module, now available in Qiskit QEC.

Specific project ideas

• Write a decoder for the qudit or non-Abelian decoding problems shown in Decoding 4: Programming HDRG Decoders.
  • Explain your method
  • Provide your code
  • Provide threshold graphs for different values of k
• A recent scheme for benchmarking known as the layer fidelity has some similarities to my old game-based benchmark, Quantum Awesomeness.
  • Explain the two approaches and discuss their similarties and differences.
  • Propose a new 'Quantum Awesomeness', that uses some ideas from the layer fidelity.
  • Produce and explain some of the basic circuits required for your idea.