qiskit-advocate / qamp-spring-22 Goto Github PK

Description

Qiskit's circuit library is a collection of important quantum circuits we can use to build algorithms, applications and investigate quantum advantages. By using it we can quickly set up more complicated workflows and we can use circuits in our algorithms that have proven to be efficient in practice.

However, it's not clear to everyone what is available in the circuit library and users might be missing out on a lot of features that would make their life easier! On top, there are many open, recurring questions on circuits: what ansatz is the best for my variational algorithm? And why?

In this project, our goal is to produce material that allows everyone to use the circuit library efficiently. We will write a Qiskit tutorial, and potentially other resources like a Medium blogpost, which explain

• which circuits exist in the library
• why they are important, and
• how you can use them!

Deliverables

Qiskit tutorial and possibly other resources (open to the mentee!)

Mentors details

• Mentor 1
  • Name: Julien Gacon
  • GitHub ID: @Cryoris
  • What they do: PhD & Qiskit dev

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Interest in quantum circuits and building algorithms!
    • Solid english skills (for writing the text 🙂)
  • Nice to have:
    • Basic knowledge of quantum algorithms
    • Maybe you used the circuit library before (not required!)

Description

See Qiskit/qiskit#7727.

Deliverables

Fix Qiskit/qiskit#7727.

Mentors details

• Mentor 1
  • Name: Kevin Sung
  • GitHub ID: kevinsung
  • What they do: Qiskit Researcher

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Knowledge of Python
  • Nice to have:
    • Knowledge of LaTeX
    • Experience using qpic

Description

qiskit-alt is a high-performance Julia backend for Qiskit with a Python frontend. It is quite new and experimental. It is not distributed as part of Qiskit. The main application is computing a qubit Hamiltonian from the specification of an electronic structure problem.

There are a number of projects available, small and large. The appropriate project depends on the experience of the mentee. There are a number of issues in the qiskit-alt repo. But, the project is divided into several other repos, most of which are hosted here. These repos have their own issues. A major part of the effort is improving deployment options of Julia with the Python project. These issues are in julia_project

Note that much of the work happens on the Python side. So, if you know some Python, but don't yet know Julia, you can still contribute.

Deliverables

Open a pull request that closes an issue and work through getting it merged. Alternatively, start by opening a new issue; for instance as a sub-issue of a more open ended one.

Mentors details

• Mentor 1
  • Name: John Lapeyre
  • GitHub ID: @jlapeyre
  • What they do: Qiskit development
• Mentor 2
  • Name: Jim Garrison
  • GitHub ID: @garrison
  • What they do: Qiskit applications development

Number of mentees

2

Type of mentees

• Mentee *
  • Required:
    • Some coding and github skills.
    • Desire to contribute to an open-source project.
  • Nice to have:
    • Python experience
    • Julia experience
    • Quantum computing knowledge

Description

Implement the feature requested at Qiskit/qiskit#7628. Description copied below:

Qiskit uses the little endian convention for ordering the factors in a tensor product. For example, the statevector for a 3-qubit state would use the ordering Q2 ⊗ Q1 ⊗ Q0. It would be useful to add support for specifying the tensor product order. This could be used, for example, to request a state vector using the common big endian ordering.

This can be implemented by adding a qubit_order argument to all functions that implicitly rely on a choice of tensor product ordering. This argument would be a list of the qubit indices in the desired tensor product order. So for the example above, it would be [2, 1, 0] to get the state in big-endian order.

The following is a non-exhaustive list of functions that would be affected:

• Result.get_statevector
• Result.get_counts
• Operator
• SparsePauliOp
• Statevector
• many other things in the quantum_info module

Deliverables

Issue Qiskit/qiskit#7628 is resolved.

Mentors details

• Mentor 1
  • Name: Kevin Sung
  • GitHub ID: @kevinsung
  • What they do: Qiskit Researcher

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Knowledge of Qiskit and Python
    • Knowledge of linear algebra
  • Nice to have:
    • Software design experience

Description

retworkx is a high-performance graph library used internally by Qiskit, PennyLane, and other projects. retworkx contains efficient implementations of graph algorithms, and Qiskit Terra leverages those algorithms to efficiently manipulate quantum circuits internally.

This project is about implementing Exact and practical pattern matching for quantum circuit optimization by Iten et al. using retworkx. Qiskit Terra has an implementation of Pattern Matching (https://github.com/Qiskit/qiskit-terra/blob/master/qiskit/transpiler/passes/optimization/template_matching/template_matching.py) which is built on top of DAGDependency (https://github.com/Qiskit/qiskit-terra/blob/master/qiskit/dagcircuit/dagdependency.py).

Ideally we'd be able to replace most of current implementation with a retworkx function, such that the transpile pass can be executed faster and included as a default in Qiskit Terra. We note that maybe not all of the Python code can be ported, hence using Cython or mypyc might also became part of the project if desired.

Deliverables

• Contribute new functions to retworkx implementing the matching algorithms described in the paper
• A Pull Request to qiskit-terra replacing the old Python code with the new retworkx methods

Mentors details

• Mentor 1
  • Name: Ivan Carvalho
  • GitHub ID: @IvanIsCoding
  • What they do: Retworkx Developer

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Good knowledge of graphs and graph algorithms
    • Interested in learning a new programming language (Rust)
  • Nice to have:
    • Experience programming in compiled languages (C++, Rust, etc)
    • Experience using Qiskit Terra transpiler passes

Description

The Lanczos algorithm is a numerical method that can be used to calculate time-evolution of closed quantum system. It is a computationally efficient method for large systems and can be useful to speed up the simulation of closed-system dynamics.

Deliverables

PR to Qiskit dynamics repo to add the feature

Mentors details

• Mentor 1
  • Name: Mirko Amico
  • GitHub ID: @miamico
  • What they do: Qiskit Research

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Good knowledge of linear algebra
    • Good knowledge of Python
    • Some knowledge of quantum systems dynamics
  • Nice to have:
    • Experience in numerical methods for quantum system dynamics

Description

Qiskit Runtime is a new architecture offered by IBM Quantum that streamlines computations requiring many iterations of circuit executions and classical processing. In simple terms, this means that for iterative (repetitive) computations, the time spent queuing processes is reduced, so the overall execution time becomes significantly faster. For example, IBM researchers achieved a 120x speedup in a lithium hydride molecule simulation.

Qiskit Runtime allows to design custom runtime programs to run experiments in the remote runtime server, as well as runtime clients to interface with these programs from the user side. Quantum neural network training is a good example of iterative problem, where a training loop is defined, and multiple forward and backward passes are performed on each training step. This is why qiskit-machine-learning recently incorporated TorchRuntime, a runtime program that leverages the PyTorch machine learning library to streamline training and inference with quantum neural networks in the cloud 🎉.

Thanks to its use of PyTorch, TorchRuntime is extremely flexible in the kind of quantum machine learning problems it can tackle. The user can define any dataset or network architecture they want, be it a fully quantum, hybrid or even classical network, and customize the training hyper-parameters using the concept of hooks. While the core functionality of TorchRuntime is explained in the following tutorial, the examples are quite basic, and it can be difficult for inexperienced users to know how to implement more complex workflows.

This long introduction leads to the main goal of the project: Creating a new torch runtime tutorial that shows a more realistic usage with complex examples. One idea could be showing how to perform classification on the MNIST dataset using a hybrid quantum-classical neural network and TorchRuntime, but it can also be a chance to experiment with different QML problems and datasets.

With my help, you could dive deep into the realm of Qiskit Machine Learning, Qiskit Runtime and the mysteries of PyTorch (and with it, data serialization- the most mysterious of all). If you have found this description interesting, or would like to actually understand what I have been writing about, this might be the project for you.

While the main deliverable will be the tutorial notebook, any issues found on the way could lead to side contributions to the source code of TorchRuntime.

Deliverables

A tutorial, jupyter notebook in Qiskit Machine Learning repository, explaining the advanced functionality of TorchRuntime.

Mentors details

• Name: Elena Peña Tapia
• GitHub ID: @ElePT
• What they do: Quantum Software Eng. / Qiskit dev

Number of mentees

1

Type of mentees

Required:

• You want to learn about QML, PyTorch and Qiskit Runtime! (most importantest)
• You know Python well and are familiar with Qiskit
• You have worked with Machine Learning libraries before

Nice to have:

• Knowledge of PyTorch (it would save a lot of work to already have some basis)
• Familiarity with Qiskit Machine Learning
• You have heard of Qiskit Runtime before

Description

The cx gate is crucial for quantum computing. However, any physical implementation will be imperfect in some way. Some measure of fidelity for any proposed or implemented cx is therefore an important benchmark.

In the era of fault-tolerant quantum computation, most cx gates applied on physical qubits will be dedicated to implementing quantum error correction (QEC). This therefore motivates the characterization of cx imperfects in the context of QEC.

In this project we will look at the effect of having a single imperfect cx within an otherwise perfect QEC protocol. The aim is to define a new QEC-inspired measure of fidelity that can be calculated from theoretically derived or experimentally measured tomography of a candidate cx.

Deliverables

The aim is to define a new QEC-inspired measure of fidelity that can be calculated from theoretically derived or experimentally measured tomography of a candidate cx.

The results of this work should hopefully be included in a paper. In this case, it will hopefully be possible for the mentee to be an author.

Mentors details

• Mentor
  • Name: James Wootton
  • GitHub ID: @quantumjim
  • What they do: QEC Researcher

Number of mentees

1

Type of mentees

• Mentee
  • Required:
    • Knowledge of linear algebra
  • Nice to have:
    • Knowledge of QEC

Description

When using Qiskit Metal, after components are added to the design, Rebuild has to happen to populate the Pandas tables. These tables are QGeometry tables and NetInformation tables. They are used to render to different tools i.e. Metal GUI, GDS file, Ansys

The Pandas tables have to be accurate.

The rebuild can waste time when rebuilding components that have not been changed. The project is to add some logic to determine which components can avoid the need to rebuilt.

Deliverables

Start a way to identify ways to reduce the number of components that need to be rebuilt. Mentors can help with that, and the logic needs to be implemented in Metal back-end code.

Mentors details

• Mentor 1
  • Name: Priti Shah
  • GitHub ID: @priti-ashvin-shah-ibm
  • What they do: Qiskit Metal core developer

Number of mentees

1

Type of mentees

• Mentor 1
  • Required:
    • Python
  • Nice to have:
    • Have installed and used Metal, edited components within a notebook.
    • Created a custom component.

Description

The proposal of this project is to generate a quantum circuit that can represent a Quantum RNN and make the connection with a classical model with the purpose of making a prediction of sotck prices. For this purpose we consider as reference the papers ref1, ref2.

Deliverables

Develop the implementation of an RNN in Qiskit.
Prepare a draft for possible submission to a journal.

Mentors details

• Mentor
  • Name: Alberto Maldonado
  • GitHub ID: @MaldoAlberto
  • What they do: PhD Student

Number of mentees

1

Type of mentees

• Mentee
  • Required:
    • Interest in Variational quantum Circuit
    • Proficiency in Python and Qiskit
  • Nice to have:
    • Experience using the QML module of Qiskit

Description

Aim of our project is to build hands-on tutorials for implementing quantum machine learning algorithms with real world data sets using Qiskit. This tutorial should give learners a taste of what QML is really about. We are planning to work with various QML techniques such as Quantum Naive Bayes, Quantum k-nearest neighbor methods, Quantum Support Vector Machine and Quantum Bayesian networks.

We will be working on some of the real datasets for Prediction of student learning outcomes, Prediction of rising global surface temperature and Prediction of credit card fraud detection.

Deliverables

Output will be in the form of jupyter notebooks and journal paper.

Mentors details

Name: Dr. Manjula Gandhi.S
GitHubID: ManjulaGandhi
What they do: Associate Professor (Computer Science Faculty), Coimbatore Institute of Technology

Name: Balaji Seetharaman
GitHubID: bala-ceg
What they do: Software Engineer at Extreme Networks and Final year Master’s student at BITS Pilani

Number of mentees

2

Type of mentees

• Mentee

• Required

  • Proficiency in classical machine learning
  • Good working knowledge in python, jupyter notebook

• Nice to have

  • Good writing skills

Description

Qiskit includes a Numpy simulator backend called BasicAer. It suffers from issues in several areas, including performance, usability, and documentation. This project aims to address those issues.

Deliverables

Fix the following issues:

• Qiskit/qiskit#7670
• Qiskit/qiskit#7634
• Qiskit/qiskit#7781
• Qiskit/qiskit#3403

Mentors details

• Mentor 1
  • Name: Kevin Sung
  • GitHub ID: @kevinsung
  • What they do: Qiskit Researcher

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Knowledge of Python and Qiskit
  • Nice to have:
    • Experience in quantum circuit simulation

Description

Within Qiskit Metal, we have automatic routing software using a modified A* algorithm within QRoute code. This sometimes has collisions; need to have additional checks.

Deliverables

Add additional checks and logic for the modified A* QRoute algorithm.

Mentors details

• Mentor 1
  • Name:Priti Shah
  • GitHub ID: @priti-ashvin-shah-ibm
  • What they do: Qiskit Metal core developer
• Mentor 2
  • Name: Thomas McConkey
  • GitHub ID: @ThomasGM4
  • What they do: Qiskit Metal core developer

Number of mentees

1

Type of mentees

• Mentor 1
  • Required:
    • python programming
    • Understand the A* algorithm
  • Nice to have:
    • Used Qiskit Metal to render cpws.
• Mentor 2
  • Required:
    • item 1
  • Nice to have:
    • item 1

Description

One of the major obstacles in solving multiphysics problems on quantum devices, like the computational fluid dynamics for example, include the non-linearity of corresponding partial diff. equations describing the particular physical process. In order to be able to harvest full potential of the quantum space in solving this complex multiphysics problems, implementation of adequate algorithm is required. One of the approaches for solving non-linear PDF is proposed by J.P. Liu et. al. in paper entitled “Efficient quantum algorithm for dissipative nonlinear differential equations”, where the Carleman linearization in combination with the linear solver is described. Implementation of this algorithm on quantum devices and testing on some practical examples using Qiskit framework is the major goal of this project.

Deliverables

Quantum algorithm for solving particular set of non-linear diff. equations using the Qiskit simulator backend.

Mentors details

• Mentor 1
  • Name: Budinski Ljubomir
  • GitHub ID: @ljubabu
  • What they do: Use QC to solve CFD problems and part of Qiskit advocate squad

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Interested in developing the quantum algorithms for scientific computations.
  • Nice to have:
    • Knowledge of HHL and VQL algorithms.
    • Fundamental familiarity with partial differential equations.

Description

This project aims to investigate what happens in idling of qubits by conducting Interleaved Randomized Benchmarking (InterleavedRB) of gates with delay instructions using qiskit-experiment (c.f. qiskit-experiments/tutorials).

For example, we may examine how much the spectator qubit (q2) affects CNOT gate (on q0 and q1) fidelity by 3-qubit InterleavedRB of CNOT(q0,q1)+Delay(q2). And investigating if the fidelity can be estimated by the results from the normal 2-qubit InterleavedRB of CNOT(q1, q2) and 1-qubit InterleavedRB of Delay(q2).

The above is just an example. If you think of more interesting experimental scenario, let's pursue it!

Unfortunately, the current InterleavedRB has no full capability to conduct complicated experiments like the above experiment. So you'll have to upgrade it so that you can

• interleave Delay instructions
• create RB circuits without changing qubit layout during Clifford operations
• compare multiple interleaved RB curves with the reference RB curve
  etc.

Deliverables

A jupyter notebook investigating the results of RB of gates with delays.
Advanced: Pull requests to enhance the RB module in qiskit-experiments.

Mentors details

• Mentor
  • Name: Toshinari Itoko
  • GitHub ID: @itoko-san
  • What they do: Qiskit developer (Terra/Aer), Researcher (circuit optimization/noise modeling)

Number of mentees

1 or 2

Type of mentees

• Required:
  • Interest in Randomized benchmarking and qiskit-experiments
  • Python basics (including jupyter notebook)
• Nice to have:
  • Good knowledge of Qiskit transpiler would be helpful

Description

Currently, artists who would like to work with Qiskit must figure out how to integrate Qiskit into their creative workflow. This often means translating their work to different programming languages or finding unofficial workarounds, depending on the creative environment. We propose a project to have Qiskit integrated more natively into creative environments (such as Processing). This project would require determining which creative environments are the most used by generative artists and then figuring out how to integrate Qiskit into those environments.

Deliverables

Having Qiskit integrated into a creative environment (such as Processing) so that generative artists can work natively work with Qiskit directly.

Mentors details

• Mentor 1
  • Name: Russell Huffman
  • GitHub ID: @JRussellHuffman
  • What they do: Qiskit Design Lead
• Mentor 2
  • Name: Iskandar Sitdikov
  • GitHub ID:@IceKhan13
  • What they do: Qiskit Community Developer Advocate

Number of mentees

2

Type of mentees

• Mentee 1
  • Required:
    • Interested in generative art, or creative applications of quantum computing
  • Nice to have:
    • Experience in creative coding, artist's software/environments/libraries

Description

The variational quantum eigensolver (VQE) is a near-term suitable algorithm to minimize the expectation value of a quantum mechanical system -- and it has a huge range of applications! In a VQE we select an ansatz circuit, which we can execute well on today's devices, and then tune it's parameters so that the ansatz approaches the ground state of the system as good as possible. This parameter optimization however can be challenging!

In this project, we implement an optimization scheme that promises to use quantum resources more efficiently than our current optimizers. The idea is to adaptive select with how many shots we measure the expectation values and is described in this paper: https://arxiv.org/abs/1909.09083.

Depending on how quickly we finish this first task, we can then decide together in which direction we want to move. Do we want to benchmark this new optimizer and compare it to others? Are there other optimizers we'd like to include? Maybe you even came up with your own idea to improve the VQE!

This project can be worked on by 1-2 persons with some Python knowledge 🙂

Deliverables

A new optimizer or VQE class that is contributed to Qiskit Terra by the end of the project.

Mentors details

• Name: Julien Gacon
• GitHub ID: @Cryoris
• What they do: PhD & Qiskit dev

Number of mentees

1-2

Type of mentees

• Required:
  • Interest in the VQE!
  • You know Python basics 🙂
• Nice to have:
  • You worked with the VQE before (no requirement at all!)
  • You've used GitHub before

Description

We have draft written documentation written in Overleaf LaTex called
Qiskit Metal: A quantum device design framework and library.

We would like to have "professional" type diagrams and figures for the document.

Contributor would need to understand the flow of the python code and work with various developers to create diagrams that are meaningful.

Deliverables

Diagrams added to the latTex document.

Mentors details

• Mentor 1
  • Name: Priti Shah
  • GitHub ID: @priti-ashvin-shah-ibm
  • What they do: Qiskit Metal core developer

Number of mentees

1

Type of mentees

• Mentor 1
  • Required:
    • python to understand the flow of Qiskit Metal Code
    • Willing to create professional looking diagrams for LaTex
  • Nice to have:
    • Installed and used Qiskit Metal
    • Understand A* algorithm.

Description

Quantum neural networks (QNNs) are promising candidates to replace classical feedforward neural networks (Please see work by Abbas et al.). However, it is still unknown if or when this can happen. Understanding the potential of QNNs requires us to investigate how they perform under many noise effects that we observe on NISQ devices. In this project, we will benchmark several QNNs under different levels of noise (readout assignment error, cnot errors, depolarizing noise, etc.) and see the effect of noise and if widely used error mitigation techniques can allow us to recover the performance.

Deliverables

Performance benchmarks of QNNs under noise with and without error mitigation.

Mentors details

• Mentor
  • Name: Cenk Tüysüz
  • GitHub ID: @cnktysz
  • What they do: Physics PhD student at DESY and Humboldt University of Berlin, research on QML applications for High Energy Physics

Number of mentees

2

Type of mentees

Interest in Quantum Machine Learning.
Interest in Error Mitigation and Noisy Quantum Simulations.

Description

Quantum machine learning is gaining momentum and becoming more and more popular across machine learning researchers. This project aims facilitating smooth transition from classical to quantum machine learning algorithms for those who are already proficient in classical ML. The goal of this project is to pick up a small classical machine learning dataset and an ML problem, e.g. classification, regression, then build up a quantum model that will produce similar results. The dataset should be small enough to be processed by a quantum computer or a simulator, but in the same time it should be widely known by ML practitioners. A classical iris dataset may be a good candidate. The tutorial itself should be as close as possible to a real life Qiskit Machine Learning use case. This tutorial should be a good starting point for everybody.

Deliverables

A tutorial, jupyter notebook in Qiskit Machine Learning repository, explaining how to move from a classical algorithm an analogous quantum one.

Mentors details

Anton Dekusar, @adekusar-drl
Research Software Engineer / Qiskit Machine Learning contributor

Number of mentees

1

Type of mentees

What is required:

• Excellent writing skills and proficiency in jupyter notebook
• Proficiency in classic machine learning algorithms
• Basic knowledge of quantum machine learning

Description

Qiskit Applications (Optimization, Finance, Nature, ML) have some performance benchmarks implemented. By performance we understand various metrics like executing time, required memory and other specific metrics, e.g. score, that may arise in the benchmarks. Currently a few on them were added Qiskit Machine Learning, benchmarks for quantum neural networks. This project aims at building a set of such benchmarks for QuantumKernel.

In the project we want to do:

• Analyze the QuantumKernel code/features for potential benchmarks, e.g. tutorials and unit tests may be good places for a search for candidates.
• Re-use the existing code and implement new benchmarks
• Analyze the obtained results and suggest further improvement if any.

Current benchmarks are available here: https://qiskit.github.io/qiskit-app-benchmarks.

Deliverables

Performance benchmarks for QuantumKernel.

Mentors details

• Mentor 1
  • Name: Atsushi Matsuo
  • GitHub ID: @a-matsuo
  • What they do: Researcher at IBM Research Tokyo, Qiskit Optimization core developer

Number of mentees

1

Type of mentees

What is required:

• Good software engineering skills, ability to work with Git.
• Willingness to look through third party code.
• Proficiency in Python.
• Interested in Qiskit Machine Learning and quantum computing in general.

Description

Protein folding is the newest sampling problem released in Qiskit nature 0.2.0 (https://github.com/Qiskit/qiskit-nature/tree/main/qiskit_nature/problems/sampling/protein_folding). We would like to implement some convenience tools and extend the implementation to allow for better result interpretation and visualization of the final output.

Related issues from qiskit-nature:
qiskit-community/qiskit-nature#313
qiskit-community/qiskit-nature#235
qiskit-community/qiskit-nature#236

Deliverables

Implementation for Qiskit nature. A PR related to this would be a tangible deliverable.

Mentors details

• Mentor 1
  • Name: Panagiotis Barkoutsos
  • GitHub ID: @pbark
  • What they do: Qiskit Nature core developer / researcher
• Mentor 2
  • Name: Dariusz Lasecki
  • GitHub ID:@dlasecki
  • What they do: Qiskit Applications software engineer

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Good knowledge of Python.
  • Nice to have:
    • Familiarity with Qiskit Nature.
    • Familiarity with protein folding problem.
    • Experience with Matplotlib.

Description

We have a open source repository for Qiskit Metal at https://github.com/Qiskit/qiskit-metal/tree/main

We would like to update CI workflow testing to use python 3.10. As part of that, we would need to update Metal for 3.10 compatibility. Would need to use Metal to confirm that all features are working as expected.

Deliverables

Update Metal to be compatible with python 3.10
Add the updated code to CI testing to include python 3.10.

Mentors details

• Mentor 1
  • Name:Priti Shah
  • GitHub ID: @priti-ashvin-shah-ibm
  • What they do: Qiskit Metal core developer

Number of mentees

1

Type of mentees

• Mentor 1
  • Required:
    • Understand Python
  • Nice to have:
    • Installed and used Qiskit Metal.
    • Worked with CI Continuous Integration on Github.

Description

During CI, offer user method to reformat file to be yapf. We require all files to be formatted by yapf so the code "looks" similar. If the file is not formattted, the CI will fail. So, it would be nice to offer to reformat for the user. There are some files that have code which developers don't want to be reformatted to yapf. The solution of this project needs to address developer's wishes.

Deliverables

If CI fails due to non-formatted yapf file, provide a user-friendly solution.

Mentors details

• Mentor 1
  • Name: Priti Shah
  • GitHub ID: @priti Ashvin Shah
  • What they do: Developer for Qiskit Metal
• Mentor 2
  • Name:
  • GitHub ID:
  • What they do:

Number of mentees

1

Type of mentees

• Mentor 1
  • Required: Have experience committing to Qiskit Metal
    • item 1
  • Nice to have:
    • item 1
• Mentor 2
  • Required:
    • item 1
  • Nice to have:
    • item 1

Description

Web3 is a term used to describe the decentralized and token-based economics, provided by blockchain technology. Since its emergence many years ago via popular coins and platforms, Bitcoin, Ethereum, etc. lots of development has grown out of this technology. Nowadays more and more commercial applications and companies are getting into Web3.

For this project we would like to see if there are any potential areas where we can see how to integrate Qiskit, and quantum computing in general, to the Web3 area, asides from the already popular cryptography topic, which everyone is already writing and reading about. :)

Here's a short list of topics to consider as an example:

• How could adding quantum image processing add value to artifacts such as NFTs, token-economics, etc.?
• Are there any L1/L2 components or artifacts that can benefit by quantum?
• Some decentralization applications rely on various heavy computational tasks, can we find any that have quantum potential?

Deliverables

As a deliverable ideally we would like to complete the following:

• Research potential areas where quantum might provide computational value
• List out specifics around the computational advantage
• Complete a simple example using Qiskit
• Write a paper describing findings and submit as a proposal to publish/post as a Qiskit tutorial/application-chapter/Qiskit blog

Mentors details

• Mentor 1
  • Name: Robert Loredo
  • GitHub ID: @robertloredo
  • What they do: IBM Quantum Ambassador worldwide lead

Number of mentees

4

Type of mentees

• Mentee 1
  • Required:
    • Computational Web3 knowledge. Able to determine the computational complexity and existing challenges
    • Proficient in Qiskit
  • Nice to have:
    • Web3 development skills in any of the L1/L2 or other Web3 application development
    • Quantum information/computation experience
    • Experience in Qiskit open source contributions
• Mentee 2
  • Required:
    • Web3 development skills in any of the L1/L2 or other Web3 applications
    • Proficient in Qiskit
  • Nice to have:
    • Quantum computation/information experience
    • Experience in Qiskit open source contributions

Description

In the seminal article by Lamport, Shostak and Marshal, it was proven that no classical solution with less than 3⋅𝑚+1 generals can face 𝑚 traitors. A quantum solution for 3 generals using qutrits is described here and can be done with qubits entangled in such a way that they emulate qutrits as shown here and here.

In this project, the cases of 3 and 4 generals are solved by algorithms based respectively on entangled qutrits and entangled ququatrits. These qu-n-its are emulated by adequately entangled qubits. I tested successfully these algorithm for qutrits in Qiskit on qasm_simulator and FakeCasablanca or other mock backgrounds. For ququatrits, the algorithm passes the test on qasm simulator, or on a modified mock background (FakeSydney with gate errors and read out errors all set to their observed average across qubits).

This project seems quite close to completion for the mentees, who may be frustrated. It is therefore probably preferable that I play myself the role of the mentee if I find a mentor interested in this issue.

Deliverables

• a notebook (nearly completed)
• further testing the 4-general solution on noise models
• if possible, hardware testing for the 3-general solution
• an article submitted to qiskit Medium, or another type of publication

Mentors details

Call for a mentor (or co-author of the project) who could review the notebook, see if there are some flaws, accompany me in the verification on hardware, and help me with the publication.
I will be the mentee, but, why not, the mentor. The main point is to form a team interested by the quantum solutions of the Byzantine agreement problem.
Those who are interested can DM me on Slack @PierreDC. I shall transmit the current state of the notebook which includes a more complete description of the project in introduction.

Number of mentees

1

Type of mentees

(and of mentor)

• Interested by the Byzantine agreement problem and its quantum solutions
• Can be useful: some knowledge in areas such as finance and bitcoins, probabilities, quantum cryptography, game theory, quantum games and paradoxes

Description

The AdaptVQE algorithm, originally implemented in Qiskit Aqua as the outcome of the Qiskit Hackathon Europe 2019, link. Since then, it has been refactored multiple times, most recently during the QAMP Fall 2021 to leverage Qiskit Terra's gradient framework link.

This time around, we would like to take the algorithm one step further by decoupling it from Qiskit Nature and migrate it to Qiskit Terra, making it more widely available. More details will be provided soon.

Deliverables

Migrate the AdaptVQE algorithm from Qiskit Nature to Terra.

Mentors details

• Mentor 1
  • Name: Max Rossmannek
  • GitHub ID: @mrossinek
  • What they do: Qiskit Nature Developer
• Mentor 2
  • Name: Dariusz Lasecki
  • GitHub ID: @dlasecki
  • What they do: Qiskit Applications + Algorithms Developer

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Python knowledge
    • Knowledge of AdaptVQE
  • Nice to have:
    • knowledge of design aspects of Qiskit Terra's VariationalAlgorithm interface
    • knowledge of design aspects of Qiskit Nature's GroundStateEigensolver interface

This project will be continued from qiskit-advocate/qamp-fall-21#5 by @fs1132429

Description

We want to continue creating reusable web components for our Qiskit web projects, like Qiskti.org and the New Textbook.

We already starting developing some and want to continue creating them in https://github.com/qiskit/web-components/.

The goal is to create more Qiskit web components.

Deliverables

• Creation of a list of meaningful web components (partially based on similar UI elements already in use in our web projects)
• Prioritisation of the possible web components to identify low hanging fruits
• Opening of PRs with web components
• Reviewing and merging of PRs in the codebase

Mentors details

• Mentor 1
  • Name: Eddybrando Vásquez
  • GitHub ID: @eddybrando.vasquez
  • What they do: Quantum Community Web Development Technical Lead

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Web development knowledge
    • JavaScript knowledge
  • Nice to have:
    • Experience in TypeScript
    • Experience in web components
    • Experience in the Carbon Design System or web UI libraries / frameworks like Bootstrap or Tailwind CSS

Description

Quirk is a famous circuit composer and simulator, written by Craig Gidney. It is super flexible and it wold be great to have some sort of integration with Qiskit. Here are some ideas:

• Export a Qiskit QuantumCircuit as a Quirk url
• Import a Quirk json as a Qiskit QuantumCircuit
• Have Quirk as a QuantumCircuit builder, like an alternative to the composer widget

Deliverables

a python package (called qiskit-quirk?) with some of the integrations.

Mentors details

• Mentor 1
  • Name: Amir Ebrahimi
  • GitHub ID: @amirebrahimi
  • What they do:

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Interested in web and front-end
    • Some knowledge of circuit construction in Qiskit
  • Nice to have:
    • Experience with jupyter widgets
    • Knowledge in nodejs (for creating a standalone version, for example)

Description

• As of this writing 2022-01-29 there are 127 open Transpiler issues in the Qiskit Terra repository.
• As many participants who have the skills and the will can participate in closing Transpiler issues for the duration of the QAMP Spring 2022 event.
• If there is time and energy left over, we will look at future directions for the Transpiler.
• My intent long-term is to identify a team of Transpiler-aware Qiskit participants to take the Transpiler in a new direction in future events as noted in the qiskit-community Transpiler! discussion

Deliverables

Close as many Transpiler issues as possible.

Mentors details

• Mentor 1
  • Name: Jack Woehr
  • GitHub ID: @jwoehr
  • What they do: Lead Architect IBM i Services, Absolute Performance, Inc. Qiskit Advocate. IBM Champion 2021, 2022

Will also approach @kdk about this mentorship

Number of mentees

5

Type of mentees

• Mentee 1 - 4
  • Required:
    • Qiskit user skills
  • Nice to have:
    • Experience in Qiskit open source contributions
    • z3 exposure
    • Mad Python Skills
    • Mad math skills
• Mentee 5
  • Required:
    • Documentation and project tracking skills
  • Nice to have:
    • Experience in Qiskit open source contributions
    • Mad web skills

Description

Recently a new extension was introduced in Qiskit's transpiler - a unitary synthesis plugin API (https://qiskit.org/documentation/apidoc/transpiler_plugins.html). This API provides a hook point for external python packages to implement their own synthesis techniques and have them seamlessly exposed as opt-in options to users when they run. The aim of this project is to write a new tutorial that explains the plugin API and a particular implementation of this plugin, approximate quantum compiler (https://qiskit.org/documentation/apidoc/synthesis_aqc.html) that was introduced at the same time as the plugin API. The proposed tutorial should give a comprehensive point of view to unitary synthesis, API, and AQC from an end-user point of view and from a Qiskit developer perspective.

Deliverables

A tutorial, jupyter notebook for Qiskit Terra that covers three main topics: unitary syntheis, plugin API and approximate quantum compiler.

Mentors details

Anton Dekusar, @adekusar-drl
Research Software Engineer / Qiskit Machine Learning contributor

Number of mentees

1

Type of mentees

What is required:

• Excellent writing skills and proficiency in jupyter notebook
• Proficiency in quantum computing
• Good knowledge of Qiskit transpiler would be really helpful

Description

A recent paper on near-term, quantum-enhanced machine learning (of which I am an author) studied a theoretical bottleneck to using quantum kernels (similarity measures) in practice for ML applications involving the generation of data points. Because new data is being created in the application, there is a need to send not only that new data, but also all of the old data, to a quantum system in order to evaluate the kernel.

The paper showed how classical matrix completion can be used to alleviate that need. It also indicated that the amount of old data which needs to be sent relates to a property of the kernel matrix representing all pairwise similarity measures; namely, its rank.

While the paper successfully identified and proposed a solution to this bottleneck, it did not study what it would mean to operationalize the solution in practice. That is, it did not consider the relevant latencies and timescales for a workflow involving both quantum computation of some kernel values and classical computation to fill in the rest.

This QAMP project would study exactly this. We would study how, in practice, this quantum-enhanced ML workflow would work. We would also perform a numerical investigation workflow's timescales. In particular, we would be especially interested to look at the tradeoff between how much classical compute time is needed for the matrix completion versus the total round-trip time for the quantum kernel algorithm.

As part of this project, I hope we would leverage the Qiskit Runtime and any existing programs compatible with it. I do not envision we would write our own Runtime programs.

Paper: Kernel Matrix Completion for Offline Quantum-Enhanced Machine Learning

Deliverables

• Operationalization of the workflow.
• Quantification of timescales and latencies.
• Analysis of what properties of a data set would be necessary.

Mentors details

• Name: Travis L. Scholten
• What they do: Quantum Applications Architect

Number of mentees

2

Type of mentees

Recommended mentee background:

• Interest in QML, especially quantum kernels
• Enthusiasm for developing proficiency with the classical matrix completion technique used in the paper
• Desire to use the Qiskit Runtime (software)

Description

The qiskit-neko project: https://github.com/mtreinish/qiskit-neko is a new effort to add a proper integration test suite to the overall qiskit project. It's designed to be run in CI to ensure that a proposed change to any qiskit project doesn't break backwards compatibility or break an interface that another qiskit project is currently using. The idea behind the project is to provide feedback before we merge a pull request if an interface is potentially broken by a change and to prevent that from being merged (so it is never released). However, this project is still in it's early stages and needs to be expanded and put into CI configurations for qiskit projects. This project is to help expand the test coverage in qiskit-neko so that we have a representative set of tests and then to potentially help get it properly running in CI for all of qiskit.

Deliverables

Pull requests to qiskit-neko and potentially to other qiskit projects to start getting qiskit-neko running in CI.

Mentors details

• Mentor 1
  • Name: Matthew Treinish
  • GitHub ID: mtreinish
  • What they do: Qiskit core developer

Number of mentees

3

Type of mentees

• Mentor 1
  • Required:
    • Experience using qiskit
    • Desire to contribute to an open source software project
  • Nice to have:
    • Familiarity with software testing
    • Experience with python (specifically unittest)

Description

When taking the matrix exponential of an Hermitean matrix M (for example to compute the time evolution operator from the Hamiltonian of a closed system) it is sometimes faster to first diagonalize the matrix M = V D V^{dagger} and then exponentiate the diagonal matrix D (which is given by exponentiating the diagonal elements) instead of using the built-in method in scipy expm directly on the matrix M.

Since fixed-step solvers are meant to work for arbitrary generators (even ones that cannot be diagonalized) but this method is faster for diagonalizable generators (in particular anti-hermitian), then it would be worth adding this implementation as an option for the user and to choose this option automatically in some higher level interfaces (e.g. when using a Solver instance that only has Hamiltonian information).

There is an open issue which aims at implementing this feature here

Deliverables

Implement the feature for Qiskit dynamics through a PR.

Mentors details

• Mentor 1
  • Name: Mirko Amico
  • GitHub ID: @miamico
  • What they do: Qiskit Researcher

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Good knowledge of Python.
    • Some knowledge of quantum systems dynamics
  • Nice to have:
    • Experience in numerical methods for quantum system dynamics

Description

See Qiskit/qiskit#7720. Description copied below.

QuantumCircuit.draw should support drawing the circuit with vertical wires instead of horizontal. This is useful when the length of the circuit exceeds the width of the display area. With horizontal wires, this situation results in line wrapping, but with vertical wires no wrapping would be needed because one can scroll, and it's easier to read the circuit contents that way.

Deliverables

Fix and close Qiskit/qiskit#7720.

Mentors details

• Mentor 1
  • Name: Kevin J. Sung
  • GitHub ID: kevinsung
  • What they do: Qiskit Researcher

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Knowledge of Python
  • Nice to have:
    • Quantum computing knowledge

Description

The Amazon Braket Python SDK is an open source library that provides a framework that you can use to interact with quantum computing hardware devices through Amazon Braket.

This project is aimed to create Qiskit-Braket plugin to execute Qiskit programs against AWS Braket devices.

Deliverables

• Create a predictable and maintainable plugin to use Qiskit Terra with Braket
• Create some simple example along the lines of https://github.com/aws/amazon-braket-examples/tree/main/examples/pennylane to demonstrate how it works and what you can do
• Build a Qiskit container for Hybrid Jobs using BYOC (https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs-byoc.html)
• Create an example notebook or two along the lines of https://github.com/aws/amazon-braket-examples/tree/main/examples/hybrid_jobs

Mentors details

• Mentor 1
  • Name: Iskandar Sitdikov
  • GitHub ID: @IceKhan13
  • What they do: Quantum Developer Community Advocate

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • knowledge of Qiskit Terra
    • good SWE experience
    • good Docker knowledge
  • Nice to have:
    • AWS infrastructure

Description

There are several proposals to solve optimization problems using Quantum Algorithms, some examples can be found in the Qiskit textbook, were an application of the Quantum Approximate Optimization Algorithm (QAOA) is presented and described. When we need to take into account the spatial dimension in an optimization problem, we are in the realm of Regional Sciences. In these problems, we work on grouping regions based on an objective function, merging adjacent locations into a homogenous regional cluster.

In this QAMP we are looking forward to explore the application of Quantum Computing to the Regional Science field, where several optimization formulations have been proposed and solved using heuristic methods that approximate an optimal solution.

Deliverables

• Develop a Qiskit implementation from regional science optimization problem
• Summarize the findings and methods on a draft paper for potential submission to peer-reviewed journal

Mentors details

• Mentor
  • Name: Daniel Sierra-Sosa
  • GitHub ID: @dsierrasosa
  • What they do: Assistant Professor, Hood College.
    Quantum Computing researcher and enthusiast

Number of mentees

1

Type of mentees

• Mentee
  • Required:
    • Interest in optimization problems
    • Proficiency in Python and Qiskit
  • Nice to have:
    • Background on classical optimization

Description

The aim of this project is to make code contributions to Qiskit.
We will solve the issues around operators (opflow, quantum_info.operators, nature.operators). For example,

• Overloading @ for Operator class #7502
• New grouping (general commuting grouping)
• Type Hint for quantum_info.
• Inplace methods for operators.
• SparsePauliOp.sort()
  and...

As above, there are easy to hard issues.

Deliverables

Code contribution (creating PRs. to Qiskit Terra or Nature)

Mentors details

• Mentor 1
  • Name: Ikko Hamamura
  • GitHub ID: @ikkoham
  • What they do: Researcher and Qiskit dev

Number of mentees

3

Type of mentees

• Software engineering skills, especially Python and Git

Description

The Qiskit Metal project aims towards developing an open-source end-to-end toolchain for Superconducting quantum device design. This requires an in-built GUI to render the components of the chip as well as a connection to a FEM solver to obtain parasitic capacitance matrix and/or electromagnetic fields associated with the on-chip components, and. then use them to tune the component parameters for best real-world performance.

Presently Qiskit Metal only connects to the Ansys Q3D and HFSS backends, which are not open-source and thus, cannot be accessed by everyone.

The goal of this project is to pick an open-source FEM solver (like FreeFEM, Elmer, etc) or generic PDE solvers (like FEniCS Project), and develop a connection interface to Qiskit Metal to make superconducting device design more accessible with a fully open-source design pipeline!

Deliverables

• Python script for the Qiskit Metal to FEM software renderer
• A jupyter notebook for reference implementation and demo
• A possible PR to the Qiskit Metal GitHub repo (can continue to work on this and refine it even after QAMP-Spring-22!)

Mentors details

• Mentor 1
  • Name: TBD
  • GitHub ID: TBD
  • What they do: TBD

Number of mentees

2

Type of mentees

• Mentee 1
  • Required:
    • Good knowledge of Python
    • Basic knowledge of electronic circuit analysis and Electromagnetic theory
  • Nice to have:
    • Some experience with using GUI (or CLI) based FEM solver softwares.
    • Basic knowledge of superconducting qubits and cQED (some useful resources: 1, 2, 3)
    • Knowledge of different analyses in Qiskit Metal (Lumped Capacitive, Quasi-Lumped, EPR)

Description

Qiskit.org is the main landing page for Qiskit, build in Nuxt using Vue.js and TypeScript.

The goal is to increase the testing coverage this web project.

Deliverables

• Creation of a list of meaningful tests (partially based on reported past issues)
• Prioritisation of the possible tests to identify low hanging fruits
• Opening of PRs with tests written in Jest
• Reviewing and merging of tests in the codebase

Mentors details

• Mentor 1
  • Name: Eddybrando Vásquez
  • GitHub ID: @eddybrando.vasquez
  • What they do: Quantum Community Web Development Technical Lead

Number of mentees

1

Type of mentees

• Mentee 1
  • Required:
    • Web development knowledge
    • JavaScript knowledge
  • Nice to have:
    • Experience in web development testing
    • Experience in Vue.js, React or Angular

Description

The goal of this project is for you to gain the knowledge of the full workflow of running VQE on a IBM Quantum system.

You will learn the VQE basics and several techniques that can be implemented to improve the fidelity of the outcomes when running the circuits on a near-term quantum computer by building your own VQE example to execute on an IBM Quantum system.

You will understand the purpose of the variational algorithm for a near-term quantum computer, how to construct a parametrized circuit to measure energy expectation value for a given Hamiltonian, apply Mapomatic (https://github.com/Qiskit-Partners/mapomatic) to find a good compiled circuit with the lowest noise, understand the need for a particular optimization algorithm like SPSA when running on a real quantum computer. We will also utilize measurement mitigation techniques in several versions, full, tensored and finally M3 (https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.2.040326), (https://github.ibm.com/IBM-Q-Software/mthree) and understand the reasons for these different approaches.

Deliverables

A jupyter notebook that can be a tutorial

Mentors details

• Mentor 1
  • Name: Hwajung Kang
  • GitHub ID: HwajungKang
  • What they do: Education Delivery Program Manager

Number of mentees

1

Type of mentees

• Required:
  • Basics of quantum computing and Qiskit
  • Python basics
  • Github experience
• Nice to have:
  • Experience of using IBM Quantum systems

Description

retworkx is a high performance general purpose graph library for python3 written in Rust to take advantage of the performance and safety that Rust provides. It was built as a replacement for Qiskit's previous networkx usage (hence the name) but is designed to provide a high performance general purpose graph library for any python application. The project was originally started to build a faster directed graph to use as the underlying data structure for the DAG at the center of qiskit-terra's transpiler, but it has since grown to cover all the graph usage in Qiskit and other applications. We use retworkx at the core of many of Qiskit's algorithms and functions (including the transpiler) when a graph representation is needed.

The full list of good first issues in retworkx can be found here.

Deliverables

The project is to work through good first issues on retworkx. So ideally pull requests and reviews of others pull requests on retworkx are the deliverable for this project. However, as it is a fairly open ended project to get involved in the development of retworkx the exact deliverables aren't set in stone. In previous iterations mentees have helped opened pull requests to other projects using retworkx along with other related tasks

Mentors details

• Mentor 1
  • Name: Matthew Treinish
  • GitHub ID: mtreinish
  • What they do: Qiskit core developer

Number of mentees

5

Type of mentees

• Mentor *
  • Required:
    • Some experience programming
    • Desire to contribute to an open source project
  • Nice to have:
    • Experience in Python
    • Experience in Rust (this is not expected and can be learned during the mentorship)
    • Experience with graph theory