# Introduction

The Quantum Katas are a collection of self-paced tutorials and programming exercises to help you learn quantum computing and Q# programming.

Each kata is a separate set of exercises that includes:

- A sequence of tasks progressing from easy to hard. Each task requires you to fill in some code. The first task might require just one line, and the last one might require rather complicated code.
- A testing framework that sets up, runs, and validates your solutions. Each task is covered by a unit test which initially fails. Once you write the code to make the test pass, you can move on to the next task.
- Links to quantum computing and Q# reference material you might need to solve the tasks.
- Hints, reference solutions and detailed explanations to help you if you're stuck.

The Quantum Katas also include *tutorials* that introduce the learner to the basic concepts and algorithms used in quantum computing, starting with the necessary math (complex numbers and linear algebra). They follow the same pattern of supplementing the theory with Q# demos and hands-on programming exercises.

## Table of contents

## Learning path

Here is the learning path we suggest you to follow if you are starting to learn quantum computing and quantum programming. Once you're comfortable with the basics, you're welcome to jump ahead to the topics that pique your interest!

#### Quantum Computing Concepts: Qubits and Gates

**Complex arithmetic (tutorial)**. Learn about complex numbers and the mathematics required to work with quantum computing.**Linear algebra (tutorial)**. Learn about vectors and matrices used to represent quantum states and quantum operations.**The qubit (tutorial)**. Learn what a qubit is.**Single-qubit gates (tutorial)**. Learn what a quantum gate is and about the most common single-qubit gates.**Basic quantum computing gates**. Learn to apply the most common gates used in quantum computing.**Multi-qubit systems (tutorial)**. Learn to represent multi-qubit systems.**Multi-qubit gates (tutorial)**. Learn about the most common multi-qubit gates.**Superposition**. Learn to prepare superposition states.

#### Quantum Computing Concepts: Measurements

**Single-qubit measurements (tutorial)**. Learn what quantum measurement is and how to use it for single-qubit systems.**Multi-qubit measurements (tutorial)**. Learn to use measurements for multi-qubit systems.**Measurements**. Learn to distinguish quantum states using measurements.**Distinguish unitaries**. Learn to distinguish unitaries by designing and performing experiments with them.**Joint measurements**. Learn about using joint (parity) measurements to distinguish quantum states and to perform state transformations.

#### Q# and Microsoft Quantum Development Kit Tools

**Visualization tools (tutorial)**. Learn to use the various tools for visualizing elements of Q# programs.

#### Simple Algorithms

**Random number generation (tutorial)**. Learn to generate random numbers using the principles of quantum computing.**Teleportation**. Implement standard teleportation protocol and its variations.**Superdense coding**. Implement the superdense coding protocol.

#### Quantum Oracles and Simple Oracle Algorithms

**Quantum oracles (tutorial)**. Learn to implement classical functions as equivalent quantum oracles.**Exploring Deutsch and Deutsch–Jozsa algorithms (tutorial)**. Learn to implement classical functions and equivalent quantum oracles, and compare the quantum solution to the Deutsch–Jozsa problem to a classical one.**Deutsch–Jozsa algorithm**. Learn about quantum oracles which implement classical functions, and implement Bernstein–Vazirani and Deutsch–Jozsa algorithms.**Simon's algorithm**. Learn about Simon's algorithm.

#### Grover's search algorithm

**Implementing Grover's algorithm**. Learn about Grover's search algorithm and how to write quantum oracles to use with it.**Exploring Grover's search algorithm (tutorial)**. Learn more about Grover's search algorithm, picking up where the Grover's algorithm kata left off.**Solving SAT problems using Grover's algorithm**. Explore Grover's search algorithm, using SAT problems as an example. Learn to implement quantum oracles based on the problem description instead of a hard-coded answer. Use Grover's algorithm to solve problems with an unknown number of solutions.**Solving graph coloring problems using Grover's algorithm**. Continue the exploration of Grover's search algorithm, using graph coloring problems as an example.**Solving bounded knapsack problem using Grover's algorithm**. Learn how solve the variants of knapsack problem with Grover's search.

#### Tools and libraries/Building up to Shor's algorithm

**Quantum Fourier transform**. Learn to implement quantum Fourier transform and to use it to perform simple state transformations.**Phase estimation**. Learn about phase estimation algorithms.

#### Entanglement games

#### Reversible computing

**Truth tables**. Learn to represent and manipulate Boolean functions as truth tables and to implement them as quantum operations.**Ripple-carry adder**. Build a ripple-carry adder on a quantum computer.

#### Miscellaneous

**BB84 protocol**. Implement the BB84 key distribution algorithm.**Bit-flip error correcting code**. Learn about a 3-qubit error correcting code for protecting against bit-flip errors.**Unitary patterns**. Learn to implement unitaries with matrices that follow certain patterns of zero and non-zero elements.**Quantum classification (tutorial)**. Learn about circuit-centric classifiers and the quantum machine learning library included in the QDK.

For a Q# programming language quick reference sheet, see Q# Language Quick Reference.

## Run the katas and tutorials online

The Quantum Katas are now available as Jupyter Notebooks online! See index.ipynb for the list of all katas and tutorials, and instructions for running them online.

While running the Katas online is the easiest option to get started, if you want to save your progress and enjoy better performance, we recommend you to choose the local option.

## Run the katas locally

### Quantum Development Kit Installation

To use the Quantum Katas locally, you'll need the Quantum Development Kit, available for Windows 10, macOS, and Linux. If you don't already have the Quantum Development Kit installed, see the install guide for the Quantum Development Kit.

**If you want to run the katas and tutorials locally as Jupyter Notebooks**:

- Follow the steps in the QDK install guide for Python and the QDK install guide for Jupyter Notebooks.
- Several tutorials require installing additional Python packages:
- "Complex arithmetic" and "Linear algebra" require the
`pytest`

package. - "Exploring Grover's search algorithm" requires the
`matplotlib`

package. - "Quantum classification" requires
`matplotlib`

and`numpy`

packages.

- "Complex arithmetic" and "Linear algebra" require the

Refer to Updating IQ# kernel for updating IQ# kernel to a new version with monthly QDK releases.

**If you want to run the katas and tutorials locally as Q# projects**:

Follow the steps in the QDK install guide for Visual Studio, Visual Studio Code or other editors.

Running the Q# projects of the Katas locally requires downloading and installing the .NET 6.0 SDK. You can do this even if you have another .NET version installed, since multiple versions are supported side-by-side.

Since Visual Studio 2019 does not support .NET 6.0 projects, you will need to upgrade to Visual Studio 2022 and install the corresponding Microsoft Quantum Development Kit extension.

### Download the Quantum Katas

If you have Git installed, clone the Microsoft/QuantumKatas repository:

`$ git clone https://github.com/Microsoft/QuantumKatas.git`

[!TIP] Both Visual Studio 2022 and Visual Studio Code make it easy to clone repositories from within your development environment. For details, see the Visual Studio and Visual Studio Code documentation.

If you don't have Git installed, download the katas from https://github.com/Microsoft/QuantumKatas/archive/main.zip.

### Run a kata as a Jupyter Notebook

The best way to run the katas as Jupyter Notebooks is to navigate to the root folder of the repository and to open `index.ipynb`

using Jupyter:

```
$ cd QuantumKatas/
$ jupyter notebook index.ipynb
```

This will open the notebook that contains a list of all katas and tutorials, and you will be able to navigate to the one you want using links.

Note that this will start Jupyter Notebooks server in the same command line window you used to run the command. If you want to keep using that window for navigation, you can launch Jupyter Notebooks server in a new window using the following commands (on Windows):

`$ cd QuantumKatas/ $ start jupyter notebook index.ipynb`

You can also open an individual notebook directly, but this might render internal links invalid:

```
$ cd QuantumKatas/tutorials/ComplexArithmetic
$ jupyter notebook ComplexArithmetic.ipynb
```

### Run a kata as a Q# project

Each kata is in its own directory as a self-contained Q# project, solution and Jupyter Notebook triplet. For instance, the BasicGates directory structure is:

```
QuantumKatas/
BasicGates/
README.md # Instructions specific to this kata. .vscode/ # Metadata used by Visual Studio Code. BasicGates.sln # Visual Studio solution file. BasicGates.csproj # Project file used to build both classical and quantum code. BasicGates.ipynb # Jupyter Notebook front-end for this kata. Tasks.qs # Q# source code that you will fill as you solve each task. Tests.qs # Q# tests that verify your solutions. TestSuiteRunner.cs # C# source code used to run the Q# tests. ReferenceImplementation.qs # Q# source code containing solutions to the tasks.
```

To open the **BasicGates** kata in Visual Studio 2022, open the **QuantumKatas/BasicGates/BasicGates.sln** solution file.

To open the **BasicGates** kata in Visual Studio Code, open the **QuantumKatas/BasicGates/** folder.
Press **Ctrl + Shift + P** (or **⌘ + Shift + P** on macOS) to open the **Command Palette**. Type **Open Folder** on Windows 10 or Linux or **Open** on macOS.

[!TIP] Almost all commands available in Visual Studio Code are in the Command Palette. If you get stuck, press

Ctrl + Shift + P(or⌘ + Shift + Pon macOS) and start typing to search through all available commands.You can also launch Visual Studio Code from the command line:

$ code QuantumKatas/BasicGates/

### Run kata tests

Once you have a kata open, it's time to run the tests using the following instructions.
Initially all tests will fail. Don't panic!
Open **Tasks.qs** and start filling in the code to complete the tasks. Each task is covered by a unit test. Once you fill in the correct code for a task, rebuild the project and re-run the tests, and the corresponding unit test will pass.

#### Visual Studio 2022

- Build the solution.
- From the main menu, open
**Test Explorer**(**Test**>**Windows**) and select**Run All**to run all unit tests at once. - Work on the tasks in the
**Tasks.qs**file. - To test your code changes for a task, rebuild the solution and re-run all unit tests using
**Run All**, or run just the test for that task by right-clicking the test and selecting**Run Selected Tests**.

#### Visual Studio Code

- Press
**Ctrl + `**(or**⌘ + `**on macOS) to open the integrated terminal. The terminal should open to the kata directory. If it doesn't, navigate to the folder containing the *.csproj file for the kata using`cd`

command. - Run
`dotnet test`

in the integrated terminal. This should build the kata project and run all of the unit tests. All of the unit tests should fail. - Work on the tasks in the
**Tasks.qs**file. - To test your code changes for a task, from the integrated terminal run
`dotnet test`

again.

For convenience, a tasks.json configuration file exists for each kata. It allows Visual Studio Code to run the build and test steps from the Command Palette.
Press **Ctrl + Shift + P** (or **⌘ + Shift + P** on macOS) to open the Palette and type **Run Build Task** or **Run Test Task** and press **Enter**.

## Run katas locally with Docker

You can use the included Dockerfile to create a docker image with all the necessary tools to run the katas from the command line or Jupyter.

- Install Docker.
- Build the docker image and tag it
`katas`

:

`docker build -t katas .`

- Run the image in the container named
`katas-container`

with interactive command-line and redirect container port`8888`

to local port`8888`

(needed to run Jupyter):

`docker run -it --name katas-container -p 8888:8888 katas /bin/bash`

- From the same command line that you used to run the container, run the C# version of the
**BasicGates**kata:

```
cd ~/BasicGates/
dotnet test
```

- Start a Jupyter Notebook within the image for the
**BasicGates**kata:

`cd ~/BasicGates/ && jupyter notebook --ip=0.0.0.0 --no-browser`

- Once Jupyter has started, use your browser to open the kata in notebook format. You will need a token generated by Jupyter when it started on the previous step:

`http://localhost:8888/notebooks/BasicGates.ipynb `

To exit a docker container without killing it (daemon mode), press **Ctrl+P, Ctrl+Q**

To re-enter the existing `katas-container`

(in daemon mode):

`docker attach katas-container`

Once you're done, remove the `katas-container`

:

`docker rm --force katas-container`

# Contributing

This project welcomes contributions and suggestions. See How Can I Contribute? for details.

# Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.