Abstract

Creating a chess game where some chess pieces exhibit quantum properties (teleportation, entanglement, superposition and interference ) while the board exhibit noise i.e it can loose your chess piece

Abstract

Matrix inversion is one of the most important computational primitives in the world today. HHL is the canonical long-term quantum algorithm for matrix inversion, but in the last several months, several near-term variational algorithms have been proposed. One promising proposal is https://arxiv.org/abs/1909.07344, which uses linear combinations of circuits to represent a solution.

Description

Implement a proof-of-concept of this algorithm using Aqua, and test it on a series of trial matrices.

Members

Deliverable

A python implementation of the algorithm, and a notebook demonstrating the algorithm's performance on a series of trial matrices.

GitHub repo

Abstract

This paper goes into a lot of detail about it.

This paper helps explain the approach more intuitively.

This blog post from Xanadu is also very useful. (it's also where I took the above image from)

Xanadu's pennylane platform has an implementation of this optimizer; however, pennylane is set up differently than qiskit-so it will not be a copy-paste situation.

Members

• Qiskit Coach: {githhub: @BryceFuller, slack: @bryce Fuller}

Deliverable

An optimizer module that we can use within qiskit. Some pretty graphs showing how well our optimizer performs under stochastic noise.

GitHub repo

Abstract

Algorithms are sometimes used to generate things like maps, levels, puzzles or even stories for games. This is procedural generation. Let's do it with a quantum computer!

Description

A proof-of-principle project on quantum terrain generation has already been done. See this tutorial for more information. This could be adapted or used as inspiration.

A possibility that is currently being explored us using quantum networks as the basis for games or procedural story generation. See here for a prototype and an example use case.

Note: This project is not about using quantum randomness to create random things. Ideally, the content generated should always be the same when the same seed is used.

Members

• Member list will be created in the comments below.
• Qiskit Coach: @quantumjim (Coaching from afar. Available as 'James Wootton' on the Qiskit Slack.

Deliverable

A Jupyter notebook generating some interesting content, and explaining how it is done.

GitHub repo

• Link will be posted in the comments below.

Abstract

QVMC optimisation implimentation on Qiskit for ground state and exception energy calculations .

Description

The aim of this project is to implement QVMC optimisation on Qiskit. This can be used in chemistry applications to calculate ground state and excitations state of molecules. Other applications include optimisation in finance.

Members

• @lmongalo
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @githubhandle

Deliverable

GitHub repo

Abstract

Explore different ways of classifying and analyzing the results of qubit measurements.

Description

Qubit measurement is a process that consists of generating a measurement
pulse, having the pulse interact with the qubit, reading out voltages,
integrating the voltages into IQ values, and classifying the IQ values
as a particular measurement outcome.

The goal of this project is to understand and characterise this pipeline.

Members

• @hodgestar @mmibrah2 @KrupaPrag @amindila @mugi-hub
• Qiskit Coach: @nbronn

Deliverable

• Understand qubit measurement and pulse control.
• Investigation of measurement performance as a function of measurement pulse frequency.
• Characterisation of X and K for a qubit.
• Created improved discriminators.

GitHub repo

https://github.com/hodgestar/qiskit-pop-kernels/

Abstract

Currently only statevector is supported in gpu branch. This proposal adds support unitary and density matrix simulator as master branch does for statevector.

Description

UnitaryMatrix and DensityMatrix extends QubitVector in master branch.
On the other hand, QubitVectorThrust behaves as QubitVector with thrust library that use GPUs if they exist. As UnitaryMatrix and DensityMatrix, UnitaryMatrixThrust and DensityMatrixThrust can be implemented by extending QubitVector.

Required skills:

• C++
• Python (Optional)

References

• Installation Guide
• Note: PR491 may be necessary to enable Thrust with OpenMP.

First step

1. Follow the Installation Guide to setup development environment.
2. Run the following commands

mkdir build/
cd build/
cmake -D AER_THRUST_BACKEND=OMP ..
make
ls Release/

3. Run standalone simulator

• create test.json, and

{
    "qobj_id": "u1",
    "schema_version": "1.0.0",
    "type": "QASM",
    "config": {
        "method": "statevector_gpu",
        "seed": 1
    },
    "experiments": [
        {
            "config": {
                "shots": 1,
                "memory_slots": 16,
                "n_qubits":16 
            },
            "header": {
                "name": "u1",
                "qreg_sizes": [["qr", 16]],
                "qubit_labels": [
                     ["qr", 0],["qr", 1],["qr", 2],["qr", 3],["qr", 4],["qr", 5],["qr", 6],["qr", 7],["qr", 8],["qr", 9],
                     ["qr", 10],["qr", 11],["qr", 12],["qr", 13],["qr", 14],["qr", 15]
                ]
            },
            "instructions": [
                {"name": "u1", "params": [0.5], "qubits": [0]},
                {"name": "u1", "params": [0.5], "qubits": [1]},
                {"name": "u1", "params": [0.5], "qubits": [2]},
                {"name": "u1", "params": [0.5], "qubits": [3]},
                {"name": "u1", "params": [0.5], "qubits": [4]},
                {"name": "u1", "params": [0.5], "qubits": [5]},
                {"name": "u1", "params": [0.5], "qubits": [6]},
                {"name": "u1", "params": [0.5], "qubits": [7]},
                {"name": "u1", "params": [0.5], "qubits": [8]},
                {"name": "u1", "params": [0.5], "qubits": [9]},
                {"name": "u1", "params": [0.5], "qubits": [10]},
                {"name": "u1", "params": [0.5], "qubits": [11]},
                {"name": "u1", "params": [0.5], "qubits": [12]},
                {"name": "u1", "params": [0.5], "qubits": [13]},
                {"name": "u1", "params": [0.5], "qubits": [14]},
                {"name": "u1", "params": [0.5], "qubits": [15]}
            ]
        }
    ]
}

• Run the simulator, and confirm statevector_fake_gpu method is used.

$ Release/qasm_simulator test.json | grep statevector
            "method": "statevector_fake_gpu",

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @githubhandle

Deliverable

• A new unitary simulator that enables GPU
• Standalone unitary simulator for CPU and GPU
• Benchmarks for unitary simulator

GitHub repo

https://github.com/bytesalad/qiskit-aer/tree/gpu

Abstract

Given a circuit and the properties of a device, estimate the fidelity of the output of the circuit. We can also say, given a circuit and backend, what is the probability that the solution will have a fidelity within x% of the solution.

Members

Deliverable

A Qiskit python module and a notebook demonstrating the proof-of-concept for the utility, and at least one test comparing results against an experiment on hardware.

GitHub repo

Abstract

Pulse level control was previously only available to researchers in the physical lab. With the release of OpenPulse, pulse level optimization of standard gates is now available to users over the cloud. Using OpenPulse, we implement a fine calibration routine for the Xpi/2 gate, a standard gate in the qiskit gateset, enabling optimization and customization of single qubit gates for the user.

Description

Members

• Qiskit Coach: Jin-Sung Kim - Slack: @jin-sung kim email: [email protected]

Deliverable

A jupyter notebook

GitHub repo

Abstract

In a previous camp, participants noticed that the way a layout is scored might not have a good correlation with how many swaps are needed at the end.

More info in Qiskit/qiskit#3522 and qiskit-community/qiskit-camp-asia-19#4

Description

The project needs some knowledge on graph theory, but nothing big. No quantum background is needed! Some Python is a require.

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @1ucian0

Deliverable

Terra transpiler pass or passes.

GitHub repo

Abstract

Generating beats with quantum circuits

Description

We will be making a simple program that takes in beats and learn how the beat was composed and then the machine has to make a unique beat form what is has learned from the previous beats. So basically what we will be making is a model that can create a beat from the current ones that it has learned from

Members

• @Mabonito - email: [email protected]
• @scottoshiro2 - Slack: @soshiro email: [email protected]
• Qiskit Coach: @omarcostahamido @lcapelluto

Deliverable

a github repo, a jupyter notebook

GitHub repo

https://github.com/omarcostahamido/Qu-Beats

Abstract

This paper goes into a lot of detail about it.

This paper helps explain the approach more intuitively.

This blog post from Xanadu is also very useful. (it's also where I took the above image from)

Xanadu's pennylane platform has an implementation of this optimizer; however, pennylane is set up differently than qiskit-so it will not be a copy-paste situation.

Members

• Qiskit Coach: {githhub: @BryceFuller, slack: @bryce Fuller}

Deliverable

An optimizer module that we can use within qiskit. Some pretty graphs showing how well our optimizer performs under stochastic noise.

GitHub repo

https://github.com/oliverfunk/quantum-natural-gradient.git

Abstract

Variational quantum eigensolver (VQE) is a hybrid quantum algorithm to find the ground state of an input Hamiltonian. There are several classical optimizer available in Qiskit Aqua such as SPSA and Cobyla. See the full list.

Let's implement more optimizers for VQE of Aqua. There are a couples of options as follows.

• You come up with new optimization algorithms and implement them
• You look for papers about optimization of VQE and implement them, e.g., Subspace-search variational quantum eigensolver for excited states
• You look for open source libraries of optimization and integrate them into Aqua, e.g., Optuna, Hyperopt, and RBFOpt.

Description

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @t-imamichi

Deliverable

• Aqua PR https://github.com/Qiskit/qiskit-aqua

GitHub repo

Abstract

Implementing a circuit for a quantum walk, and studying its behavior when we change its evolution rules. Possibly using it to simulate some simple particle physics process.

Description

Random walks are a fundamental concept in Mathematics, Computer Science and Physics. The walker's position is distributed according to a normal distribution of variance σ ~ √n, where n is the number of steps of the walk.

In the quantum analogue of random walks, quantum walks, the walker interferes destructively around the origin. This way, the variance grows as σ ~ n (quadratically faster). They can be used for search algorithms (with quadratic speedups), simulation of particle physics... A very nice introduction to this topic is chapter 1 of this reference.

Fig. taken from [Chandrashekar2010].

The idea of the project is to implement a quantum walk in 1D on an arbitrary number of nodes, following either this paper or this one. Then, we can study how its behavior changes when we modify the so-called coin operator. We can also implement a quantum walk that actually simulates some process of particle physics (to be discussed!).

If this first goal is met, we can try to implement it on a 2-dimensional square grid.

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @VicPinaCanelles

Deliverable

GitHub repo

Abstract

OpenPulse has no mock backend to test spin based quantum hardware.

Description

Allow Qiskit to compile to a native gate set and decompose the gates to native pulse operations on qubits consisting of nitrogen vacancy centers and Carbon-13 nuclear spins. The mock backend is currently used to test qubit operations on specific quantum hardware.

Members

• @faraimazh @sapmarvins @Adeola80 @ttnkinyili @Maphai
• Qiskit Coach: @nbronn @dime10

Deliverable

An OpenPulse mock backend specification for NV centers and nuclear spins.

GitHub repo

http://github.com/sapmarvins/qiskit-terra

Abstract

using quantum computing to manipulate transport states

breaking down the helicopter flight into quantum states(QVE) and maximize the shock that produces the lift/drag we desire.
we will rely on the rotation matrix that gives a solution to the nse.

Description

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @githubhandle

Deliverable

GitHub repo

Abstract

Use OpenPulse to develop qubit calibration routines.

Description

Calibration routines require pulse-level access to the qubits in order to determine the correct frequency, amplitude, etc, for creating native gates such as X90 and CNOT gates. Some techniques from the scientific literature that would be interesting to implement are

• Parameter determination from error amplification (here)
• Hamiltonian tomography to determine and correct interaction terms in the cross resonance gate (here)
• The effect of spectator qubits on cross resonance (here)

Members

• @nbronn
• Qiskit Coach: @nbronn

Deliverable

GitHub repo

Abstract

Add more benchmark and run all the methods of qiskit-aer

Description

Currently, benchmark of qiskit-aer has few application with few methods. This propose aims to add more benchmark with various method configuration.

Reference

• airspeed velocity
• Example of a PR to add benchmarks

Required Skill Levels

• Python: Normal
• Qiskit: Beginner

First step

1. Install qiskit and try to use various method.

import time
import math
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.compiler import assemble, transpile
from qiskit.providers.aer import QasmSimulator


def qft(qreg, circuit):
    n = len(qreg)
    for i in range(n):
        circuit.h(qreg[i])
    
    for i in range(n):
        for j in range(i):
            l = math.pi / float(2 ** (i - j))
            circuit.u1(l / 2, qreg[i])
            circuit.cx(qreg[i], qreg[j])
            circuit.u1(-l / 2, qreg[j])
            circuit.cx(qreg[i], qreg[j])
            circuit.u1(l / 2, qreg[j])
        circuit.h(qreg[i])
        
    return circuit

qubit = 10
backend = QasmSimulator()

print ('app,method,qubit,time')

backend_options = {}
backend_options['fusion_enable'] = False

for method in [ "statevector", "density_matrix", "stabilizer", "matrix_product_state", "automatic" ]:
    q = QuantumRegister(qubit, "q")
    c = ClassicalRegister(qubit, "c")
    circ = qft(q, QuantumCircuit(q, c, name="qft"))
    circ.barrier()
    for i in range(qubit):
    	circ.measure(q[i], c[i])

    qobj = assemble(circ)
    
    backend_options['method'] = method

    start_simulation = time.time()
    backend.run(qobj, backend_options=backend_options).result()
    end_simulation = time.time()
    
    print ('qft,{method},{qubit},{simulation}'.format(
        method=method,
        qubit=qubit,
        simulation=(end_simulation - start_simulation)))

2. Run asv tool in test/benchmark

cd test/
asv run
asv publish
asv preview
# brows http://localhost:8080/

3. Add more various asv tests and investigate characteristics of simulator methods.

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @githubhandle

Deliverable

GitHub repo

Abstract

We are often asked how "accurate" a noise model in Aer is compared to the real device it is meant to model. It would be very useful to have a utility to perform such a comparison. Specifically, the utility can have two modes of execution:

1. Given a circuit, execute the circuit on the simulator and device, and compute the cross entropy between the resulting distributions.
2. Given a circuit, perform state tomography on the simulator and device to reconstruct the state, and compute the overlap between them.

Members

Deliverable

A proof of concept notebook and python module demonstrating the accuracy computation, including at least one comparison to an experiment on quantum hardware.

GitHub repo

Abstract

Video games are an excellent way to engage and interact with players. The aim of this project is to create a demo, prototype or vertical slice of a game that uses IBM Qiskit to demonstrate quantum computing concepts, create exposure and awareness to further interest in the field.

Description

Qat the Cat is an educational puzzle game that seeks to invite players to experience using Qiskit and gain exposure to quantum computing and basic quantum mechanics. The goal is to make more people realise that quantum computers are accessible now due to IBM's Qiskit API.

Members

• @NandiBee
• @Quanticnova
• @dimpho0
• @Daniela-gumme
• @annvuyanzi
• Qiskit Coach: @VicPinaCanelles

Deliverable

Application prototype - Web or mobile or desktop

GitHub repo

https://github.com/NandiBee/QCamp

Abstract

Generalized Grover Search involves counting the number of items that are marked by a black box function. This algorithm can be used for amplitude estimation.

This project implements Scott Aaronson et al's very recent algorithm:
Quantum Approximate Counting, Simplified
https://arxiv.org/abs/1908.10846

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @ismaila-at-za-ibm

Deliverable

Aqua module

GitHub repo

Abstract

Aqua has the DOcplex translator for optimization problems. It automatically generates an Ising Hamiltonian for an optimization problem and you can solve it with quantum computers by applying VQE or QAOA. Let's solve your own optimization problems or puzzles.

Description

Update (Dec 13): This project optimizes the Wi-Fi coverage using DOcplex translator of Qiskit Aqua.

Solving an optimization problem with quantum computer requires translating the optimization problem into an Ising Hamiltonian, and then pass the Ising Hamiltonian to a quantum algorithm, such as Variational Quantum Eigensolver (VQE) algorithm and Quantum Approximate Optimization Algorithm (QAOA).
The DOcplex translator can automatically generate Ising Hamiltonians from optimization models. Users just need to write models with DOcplex. Then they can apply VQE or QAOA. The DOcplex translator was introduced recently and we welcome your examples.
Note that the DOcplex translator can deal with only binary variables and equality constraints currently. We also welcome the extension of the functionality.

Qiskit Aqua: Experimenting with Max-Cut problem and Traveling Salesman problem with variational quantum eigensolver
Qiskit Aqua: Generating Ising Hamiltonians from optimization models with DOcplex

If you are interested in solving optimization problems with Grover's algorithm, see Quantum Challenge for your reference.

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @githubhandle

Deliverable

https://github.com/MQubit/Wifi-Coverage/blob/master/MaxCoverageProblem.ipynb

GitHub repo

https://github.com/MQubit/Wifi-Coverage

Abstract

This project implements the NeurIPS 2019 paper:
q-means: A quantum algorithm for unsupervised machine learning
https://papers.nips.cc/paper/8667-q-means-a-quantum-algorithm-for-unsupervised-machine-learning.pdf

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @robertloredo

Deliverable

GitHub repo

Abstract

Implement triple excitation evolutions in the UCC ansatz and test their performance against UCCSD on a few sample molecules. Alternatively, implement the popular UCCSD(T) approximation scheme and compare it to UCCSD (and/or UCCSDT).

Members

Deliverable

A python module and notebook comparing the UCCSDT module to UCCSD on a sample set of molecules with complicated electronic interaction areas (e.g. LiH at 2.3 - 2.7 Angstroms, N2, H4).

GitHub repo

Abstract

Terra is having troubles testing all the visualization modules (see Qiskit/qiskit#2968). That has on hold a bunch of issues. Probably, the way to go is mocking the external libraries that create this figures and make sure that they are called with the right parameters.

Members

Do you have experience testing? Do you breathe unittest.mock? Join us!

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @1ucian0 - Slack @luciano

Deliverable

A PR closing a lot of bugs!

Abstract

Bayesian Inference is a powerful tool for handling noise and uncertainty while learning from data. It leverages well-defined parameterized models (theory) of the system under study and raw observations of the system (data) to iteratively gain information about the uncertain parameters in the theory. For quantum algorithms run on quantum computing devices, the "model" of the system is the circuit itself run on the device with detailed noise models plus the variability introduced by measurement. A proper Bayesian treatment can be used to manage the noise on actual runs and piece together evidence gathered over those runs to arrive at useful answers that would otherwise be washed away. This project implements a Bayesian version of the well known iterative quantum phase estimation algorithm in such a way that the introduced primitives could be reused for other "Bayesified" algorithms:

Efficient Bayesian Phase Estimation:
https://arxiv.org/pdf/1508.00869.pdf

Description

Bayesian methods can be used to learn unknown parameters, average over parameters that are not of interest and select between competing models. It is a philosophically motivated, principled treatment of knowledge with uncertainty.

However, the first problem with Bayesian methods is that it requires accurate models. Fortunately, in the field of quantum computing, the "behaviour" of the system is well understood, even though the actual noise of any one run is unknown and even though the final answer is, of course, unknown. The noise and final answer enter the theory as parameters that Bayesian methods can elegantly manage.

The second problem with Bayesian methods is that it is computationally intensive. Fortunately, there are algorithms where the classical load is manageable (small number of parameters and good approximations: rejection filtering). Furthermore, for other algorithms there is the long-term hope that quantum bayesian inference may help alleviate the computational load, leading to Quantum-Classical-Quantum Hybrid systems.

Adaptive Quantum Simulated Annealing for Bayesian Inference and Estimating Partition Functions:
https://arxiv.org/abs/1907.09965

All of these considerations suggest the need for a framework to manage the "Bayesification" of algorithms.

References:
QInfer: Statistical inference software for Quantum Applications:
https://quantum-journal.org/papers/q-2017-04-25-5/pdf

Approximate Bayesian Inference via Rejection Filtering:
https://arxiv.org/pdf/1511.06458v2.pdf

Experimentally Detecting a Quantum Change Point via Bayesian Inference:
https://arxiv.org/pdf/1801.07508.pdf

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @ismaila-at-za-ibm
• Helpful backgrounds: Python, Pytorch, Probtorch, Qiskit, Statistics, Quantum Information, Noise modeling.

Deliverable

Aqua module,
Series of papers

GitHub repo

Abstract

Many educators and makers are interested in using Raspberry Pi devices as a teaching tool or creating fun projects for students and hobbyists. Having the ability to load Qiskit onto a Raspberry Pi device may be an ideal project.

Description

Load Qiskit onto a Raspberry Pi (emulator if hardware not available) that can take data input and run a quantum experiment. For example: read in a musical note and output a harmonized note. Extra credit if includes changes in Key signatures!

Challenge use interference as a means to determine an ideal chord, given the root note (or any other data) as input.

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @robertloredo

Deliverable

GitHub repo

Abstract

Computing the excited states of molecules is essential to the understanding of photochemical reactions and in turn to the design of new materials for e.g. solar cells. Last year the qEOM algorithm was designed and implemented in qiskit (https://arxiv.org/pdf/1910.12890.pdf) to compute the molecular excited states with a quantum device. One of the module of this code is unfortunately badly optimized and limits the scaling to larger molecules. In this project we will tackle this problem making the qEOM algorithm much more efficient.

Description

To do so we will need to implement some symbolic commutator algebra in qiskit. Moreover, we will need to implement a flexible mapping of a N-body fermionic operator to a qubit operator.
This project is ambitious but would have a great impact on the qiskit chemistry module and community, and could lead to further collaboration.

Members

• Qiskit Coach: @paulineollitrault
• Anesan Reddy
• Ian Joel David
• Lehlohonolo Mongalo
• Richman Sheshane
• Ilya Sinayskiy

Deliverable

an Aqua module

GitHub repo

https://github.com/paulineollitrault/COBRA

Abstract

Q-means is an unsupervised machine learning approach that is the quantum version of of the K-means clustering algorithm. The proposed q-means offers an exponential speedup in the number of points of the dataset as compared to the classical k-means algorithm. This method will applied to a malaria drug dataset to explore drug similarity

Members

• @githubhandle - @waheeda_saib
• @githubhandle - Slack: @wsaib email: [email protected]
• Qiskit Coach: @fifimatu

Deliverable

An aqua module and paper

GitHub repo

Abstract

Qiskit (Terra in particular) has several bugs tagged as good first issues. These issues are low priority, relatively simple to fix, and they can be a good introduction the Qiskit codebase. This project is about closing as many of those issues as possible.

Members

This project is a fallback to other projects. If you feel that you don't fit in any team, or your project come to a dead end before the hackathon finished, or you just want to improve your python/git/coding skills, then you are welcome here!

• member
• Qiskit Coach:
  • @1ucian0 - Slack: @luciano

Deliverable

PRs! Mostly to https://github.com/Qiskit/qiskit-terra/pulls/

Abstract

Qiskit compilation for electron spin qubits, targeting a new type of quantum hardware using electrons on a substrate of superfluid helium.

Related to issue #22

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @githubhandle

Deliverable

Terra Module

GitHub repo

electrons-on-helium_FORRESTworkshop.pdf

Description

This project converts given image dataset to quantum processable data(qubits) by utilizing PCA for dimensionality reduction and initial states for generating qubits. It can analyze the number of PCA components and produce the transformed qubits of an image dataset for a chosen IBM quantum device or simulator. The variance percentage that is being kept by PCA is also given as feedback to the user.

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @richardyoung00

Deliverable

A code module

GitHub repo

https://github.com/moswil/Qiskit-Hackathon

Abstract

Qiskit Ignis includes a simple example of quantum error correction, which can be used to benchmark near-term devices. There are things that could be improved, so let's do it.

Description

The topological_codes module implements various quantum error correcting codes, all of which can be analyzed by the same decoder: GraphDecoder. This contains a set of methods, all based on graph theory.

That's the idea, anyway. In practice there is currently only one code (the repetition code) and one decoding method (minimum weight perfect matching).

Adding new codes or decoders would be a good way to improve the project. However, better suited to a hackathon is perhaps to improve what is already there.

Specifically:

• Modify the _make_syndrome_graph method of the GraphDecoder class, in order to allow weights to be assigned to edges. Find some way to generate sensible weights given the results.
• Modify the matching method of the GraphDecoder class, in order to allow the above weights to be used.
• The decoder is pretty slow. Efforts to make it less slow would be appreciated.

Tutorials on how to use this module are here and here.

Members

• Create a member list in the comments below.
• Qiskit Coach: @ebaeumer
• Bonus Coach: @quantumjim (Coaching from afar. Available as 'James Wootton' on the Qiskit Slack.

Deliverable

A pull request to Qiskit Ignis.

GitHub repo

• Link will be posted in the comments below.

Abstract

Here is the main challenge:
Given a probability distribution, what is the circuit that can output that probability distribution using the state vector simulator.

Description

this challenge can be developed to have three components:

user interface

• allowing user to manually draw a probability distribution

rev-p

• reversing the probability distribution: finding the circuit

q-ver

• verifying that the circuit will output the desired result and allowing user to choose a different backend

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @omarcostahamido

Deliverable

a standalone tool, a paper, or whatever the group feels is fitting.

GitHub repo

tbd

Abstract

Given a collection of words (and hints) generate a Crossword Puzzle from the words.

Description

Generating crosswords is an NP-complete problem. The process is a constraint satisfaction problem and can be converted to a Boolean constraint satisfaction problem (SAT). Quantum SAT algorithms are faster than their classical counterparts.

It may be fun, if there is time, to add some creative quirks to the result.

There appears to be existing open source python code that could potentially be used as a starting point. https://github.com/gondsm/crossword_generator for example, but there should be better ones.

https://en.wikipedia.org/wiki/Crossword

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @githubhandle

Deliverable

An application that given a set of words, uses them to produce a crossword puzzle.

GitHub repo

Abstract

Find the optimal SWAP gates necessary for running a quantum circuit on the IBM Q system using SAT solver to find the best qubit placement and the A* algorithm to find the minimum SWAP gates between sub-circuits

This project will implement Atsushi Matsuo et al's algorithm:

Reducing the Overhead of Mapping Quantum Circuits to IBM Q System
https://ieeexplore.ieee.org/document/8702439

Members

• @githubhandle
• @githubhandle - Slack: @Fiona Matu
• Qiskit Coach: @fifimatu

Deliverable

Terra module

GitHub repo

Abstract

Eigendecompositions have a large variety of applications in physics, biology, mechanical engineering, ML, etc. To find the exact Eigendecomposition of a quantum system one has to employ Hamiltonian simulation techniques that require large, error-resistant systems. However, as discussed in https://arxiv.org/pdf/1810.10506.pdf an approximate Eigendecomposition can be implemented with a variational Ansatz.

Description

This contribution shall be a new algorithm in Qiskit Aqua. Check https://qiskit.org/documentation/contributing_to_qiskit.html including the installation from source.

Members

• Slack: tbd
• Qiskit Coach: @Zoufalc, [email protected]

Deliverable

Implement the algorithm (into Qiskit Aqua) discussed in https://arxiv.org/pdf/1810.10506.pdf and present proof of principle applications.

GitHub repo

https://github.com/GalenPickard/qiskit-aqua/tree/master/qiskit/aqua/algorithms/adaptive/vqed

Abstract

Create a musical loop generator that generates a “loop” by running a circuit 2^num_qubit times and playing the measured note pitch each time. The input to the circuit would be an incrementing basis state (e.g. |000> through |111>. The musician would control the output by altering the circuit before the next loop is generated.

For starters could use a three qubit circuit, with each basis state representing a pitch in a diatonic scale. A circuit with no gates would generate an ascending major scale. A circuit with three X gates would generate a descending major scale. Rotations and entanglement would allow nature to participate with the musician in the creative process.

As a stretch goal, take the same approach with rhythms, generating note duration values that the generated notes will have.

Members

• @githubhandle
• @githubhandle - Slack: @slackhandle email: [email protected]
• Qiskit Coach: @omarcostahamido

Deliverable

An app that creates loops in real-time as described above. Capability for updating the quantum circuit needs to be created, but perhaps in a very rudimentary form given the timeframe of the hackathon.

GitHub repo

Abstract

The pulse module of Qiskit has yet to be benchmarked. The purpose of benchmarking is to provide a deterministic way to assess performance of software over time. There is room for improvement in the performance of pulse operations; building benchmarks will allow us to quantify progress and justify code refactors.

Description

Part 1: Build a 100Q mocked backend

The first step in building a benchmark is creating mocked (faked) data to operate with. For pulse, we need a faked backend to test certain operations. There's a few reasons not to use real backends for this; for instance, real backends change over time -- we want our tests to be deterministic, we want to be able to run tests locally without an internet connection, and we want to avoid external dependencies.

There are already 2Q and 3Q pulse backend test mocks. The first deliverable will be to build a 100Q version, implemented in a similar way. This can as simple as handwriting the required values, and copy/pasting where it makes sense. It's a good opportunity to understand each of the backend attributes between PulseDefaults, BackendProperties, and BackendConfiguration. The backend attributes for OpenPulse systems are described here: https://arxiv.org/pdf/1809.03452.pdf

Ways to maximize time:

• BackendProperties may be skipped, or left until needed
• If you're feeling confident, go straight to part 1B and use it to help generate the solution to this part. I'd recommend first building a 4Q mocked backend by hand if you do this.

Here is the 3Q mock: https://github.com/Qiskit/qiskit-terra/blob/master/qiskit/test/mock/fake_openpulse_3q.py

Here is the existing Qiskit terra issue: Qiskit/qiskit#3312

Part 1.B: Parameterized backend

If you'd like to get right to writing benchmarking tests, skip ahead. Either of parts 1.B and 2 will present interesting challenges. There may be time for both, but prioritize how you wish.

This task would be to create a util method or a script to generate reasonable Pulse-enabled backends, given a list of parameters to fill the backend data.

Part 2: Benchmarking

Qiskit benchmarks exist here:
https://github.com/Qiskit/qiskit/tree/master/test/benchmarks

The task is to add new ones to cover pulse. The most important features of pulse to benchmark would be:

• Building Schedules (known to not be very efficient). Test append and insert operations
• Scheduling circuits (with qiskit.compiler.schedule)

Members

• Qiskit Coach: @lcapelluto

Deliverable

• The file: qiskit/test/mock/fake_openpulse_100q.py added to Qiskit Terra in a branch, with a pull request (PR) opened to master.

Either or both of:

• A method to generate, from a list of parameters, a backend mock to use for testing.
• A PR with one or more new test files in https://github.com/Qiskit/qiskit/tree/master/test/benchmarks

GitHub repo

Abstract

MicroQiskit is essentially a trial version of Qiskit, which is made available in languages other than Python 3. It contains all the basic features of writing and simulating quantum programs in Qiskit, all implemented in a minimal amount of code (~100 lines for the Python2/MicroPython/CircuitPython version). This could be ported to a new language, and a quick demo project could be made.

Description

Current Versions:

• Python2/MicroPython/CircuitPython.
• C++ (working but unfinished).

Suggestions for ports:

• C# (to be compatible with Unity and GoDot)
• Lua (to be compatible with Minetest and Pico8)

Members

• Member list will be created in the comments below.
• Qiskit Coach: @omarcostahamido
• Bonus Coach: @quantumjim (Coaching from afar. Available as 'James Wootton' on the Qiskit Slack.

Deliverable

A branch on the MicroQiskit repo with a working port.

GitHub repo

Fork github.com/quantumjim/MicroQiskit and post a link in the comments below.