Figuring out where to start is hard sometimes. We would love for you and your team to come up with your own project! However, if you need some help, here’s a list of projects that the IBM Quantum coaches have suggested.

Feel free to use, remix, or pick apart these ideas. All are encouraged! Most include the name of the coach who pitched it as well, so you know who to reach out to over Slack for help.

1. Building a quantum SUDOKU solver

Classically Douglas-Rachford is extremely effective in solving SUDOKUs (a feasibility problem), see: https://arxiv.org/pdf/1305.2657.pdf. Build a quantum variant.

2. Quantum Bioinformatics

Genome pattern classification, gene sequence analysis, epigenetics of infections, gene sequence analysis.

3. Create a project based on `QuantumGraph`

The `QuantumGraph` package is built on Qiskit and made to make using NISQ devices more intuitive (see https://github.com/qiskit-community/QuantumGraph). It was originally developed to be used as part of quantum methods for procedural generation (see https://arxiv.org/abs/2005.10327, where it is used as the AI in a Civilization-like game). However, it can be used for much more general tasks, such as imaginary time evolution (such as https://arxiv.org/abs/1901.07653).

In this project, you'll find a new and interesting task that can be tackled with `QuantumGraph`.

4. Quantum Image Processing

Image representation, image classification, image recognition, image feature extraction, image transformation (2D<-->3D, etc), image compression.

5. Benchmarking custom variational forms (ansatze) for quantum support vector machines

You might choose a dataset and see how different variational forms will perform.

Extreme bonus points, can you construct a dataset and a variational form that performs well on it (without simply inverting your feature map and building your dataset that way)

6. Create fun, approachable, examples that leverage the new Qiskit Aqua Optimization library

The new Qiskit Aqua Optimization library may be used to solve quadratically constrained quadratic programs. A sweet spot for quantum algorithms is the subset known as Quadratic Unconstrained Binary Optimization (QUBO) problems.

(see https://qiskit.org/documentation/tutorials/optimization)

Your mission is to create fun, approachable, examples of using QUBOs to solve interesting problems. The purpose of these examples would be to aid in teaching folks that are not necessarily mathematicians or physicists about QUBOs and how they may be used to solve problems.

7. Implement tomography based imaginary time evolution

The quantum method for imaginary time evolution proposed in https://arxiv.org/abs/1901.07653 implements gates whose form depends on a local tomography of the state, in order to approximate non-unitary effects. This approach is similar to the one taken in the `QuantumGraph` package (see previous project).

Implement this method in Qiskit. Either independently, or (ideally) by adding the required functionality into `QuantumGraph`. Just doing the 2-local case (for Hamiltonians and tomography) would probably be the most realistic scope to aim for.

8. Quantum ETL - (Robert)

Quantum Extract/Transform/Load from quantum sensors to systems. (photonic-enhanced sensors, quantum radar, quantum transducers, magnetometers, etc.)

9. Enabling large-scale optimization problems via parallel and distributed computation

Solving large-scale optimization problems is now limited to the size of a single quantum computer. Use parallel methods/distributed methods (e.g., Jacobi, Gauss-Seidel), to decompose a given quadratic unconstrained binary optimization (QUBO) to be solved on different quantum computers in parallel therefore enabling large-scale optimization. Which conditions on the QUBO are required?

10. Quantum Expander Codes

Build an encoder and decoder for quantum expander codes.

• https://arxiv.org/abs/1504.00822
• https://arxiv.org/abs/1808.03821
• https://arxiv.org/pdf/quant-ph/0605094.pdf
• http://people.seas.harvard.edu/~madhusudan/courses/Spring2017/scribe/lect13.pdf
11. - Exploring zero-order stochastic online optimization for VQE/QAOA

At the core of VQE/QAOA, one can find a classical optimization solver to determine the best rotation vector for the quantum evolution. This classical non-convex optmization is a black-box/ zero-order (i.e., derivate-free) solver, typically SPSA or COBYLA. There is much to be gained in improving the solver with the latest tools of zero-order optimization (from ML literature), such as the works of John Duchi and Francis Bach.

12. Shor on noisy small devices using classical support

Basically, Shor's algorithm for DLP (1994). I can explain how that works pretty well.

Edit basically if you take half of the possible solutions and have an oracle to tell you if the solution is in there with above(/below) 50% chance, one can classically solve the DLP. Well, an idea for an oracle is in a paper below.

We will need to implement the ideas from the papers below. We need to implement shor for DLP and the necessary gates. Papers https://scholar.google.com/scholar?cluster=11275231808084287077&hl=en&as_sdt=2005&sciodt=0,5 and https://pdfs.semanticscholar.org/ea2f/e564f243c3f1da92b03c4095ccae912116b9.pdf

13. Error mitigation via adding noise

A scheme to mitigate noise in quantum algorithms via adding noise and extrapolating was proposed in https://arxiv.org/pdf/1712.09271.pdf. The project will be to implement a simple example of this and seeing if running it on the IBM machine will provide an increase in fidelity.

14. Investigate the performance of the stochastic swap mapper on various circuits while changing the number of trials per layer and/or the number of times the whole circuit is transpiled. The goal would be to determine the optimal number of trials to compute for a circuit to have the best shot at obtaining the minimum swap insertions, as well as optimal number of times to compute the whole transportation.
15. Implement and simulate one error corrected qubit at different code distances. (Bacon-Shor code or Steane code or Surface code or something else). Inject different types and degrees of noise and show how the code can detect or correct the errors.
16. Implement Solovay-Kitaev algorithm for approximating a given unitary by gates from a finite set, to arbitrary accuracy.
17. Symbolic simulator for circuits defined with Parameters (should be integrated with qiskit.quantum_info.Operator and qiskit.quantum_info.State)