Source-linked AI summary
Overview and Comparison of Gate Level Quantum Software Platforms
Ryan LaRose
TL;DR
The rapid expansion of quantum software platforms makes it difficult to choose among tools for accessing real and simulated quantum devices. The paper compares four platforms across usability, language and library support, hardware, compilers, and simulators, finding different practical strengths for beginners, real-device experiments, and large-qubit simulation. Its scope is time-sensitive because quantum hardware and available platform options continue to change.
Problem
The rapid growth of quantum software platforms makes it difficult for students and researchers to decide which platform to use.
Method
The paper provides an overview and comparison of Forest, Qiskit, ProjectQ, and the Quantum Development Kit across syntax, documentation, libraries, hardware, compilers, and simulators.
Results
The platforms have distinct practical strengths: Forest, Qiskit, and the Quantum Development Kit offer good learning resources, Forest and Qiskit are suitable for real quantum computers, and ProjectQ is suited to simulating many qubits.
Takeaways & Limitations
Platform choice can be guided by programming background, learning resources, access to real quantum computers, and the need to simulate larger numbers of qubits.
Takeaways & Limitations
The comparison intentionally omits many respectable platforms, and the Quantum Development Kit has no current user-accessible quantum computer.
Abstract
from arXiv · showhide
Quantum computers are available to use over the cloud, but the recent explosion of quantum software platforms can be overwhelming for those deciding on which to use. In this paper, we provide a current picture of the rapidly evolving quantum computing landscape by comparing four software platforms---Forest (pyQuil), Qiskit, ProjectQ, and the Quantum Developer Kit (Q\#)---that enable researchers to use real and simulated quantum devices. Our analysis covers requirements and installation, language syntax through example programs, library support, and quantum simulator capabilities for each platform. For platforms that have quantum computer support, we compare hardware, quantum assembly languages, and quantum compilers. We conclude by covering features of each and briefly mentioning other quantum computing software packages.
1 Introduction
Quantum software has expanded rapidly as real, cloud-accessible quantum computers have emerged, making platform choice difficult. The paper responds with a concise comparison of four general-purpose gate-level platforms and their requirements, syntax, hardware, libraries, compilers, and simulators.
- 1 Introduction: Although quantum programming languages were previously largely theoretical, real cloud-accessible quantum computers now allow users with internet access to run quantum programs.Current devices remain small, noisy, and less powerful than classical computers.
- 1 Introduction: The growth of quantum software across many classical languages has made it difficult for students and researchers to choose a platform.The field includes well over fifty open-source projects and many quantum computer simulators.
- 1 Introduction: The paper compares Forest, Qiskit, ProjectQ, and the Quantum Development Kit as major general-purpose gate-level software platforms.Forest, Qiskit, and ProjectQ support connections to real quantum devices, while the Quantum Development Kit does not currently do so.
- 1 Introduction: The comparison examines platform requirements, installation, documentation, syntax, hardware, algorithm libraries, compilers, and quantum computer simulators.The paper presents platform-specific discussions followed by detailed cross-platform comparisons.
2 The Software Platforms
The four platforms provide different routes to quantum hardware and simulation, with distinct languages, documentation, and simulator capabilities. Hardware access is constrained by device availability and topology, while simulators vary in scale and purpose.
- Platform access: Four platforms connect users to quantum computers or simulators: pyQuil accesses Rigetti’s 8-qubit device, Qiskit and ProjectQ access IBM devices, and QDK has no current real-device access.IBM’s largest openly available device described here has 16 qubits; a 20-qubit device is restricted to IBM Q Network members.
- Languages and compilers: Quantum languages operate below host programming languages, and compilers translate instructions to match a device’s available gate set and connectivity.The paper describes Quil for Forest and OpenQASM for Qiskit, while pyQuil and Qiskit provide higher-level programming interfaces.
- Simulators: Qiskit supports local unitary simulation of about 12 qubits and state-vector simulation of up to about 25 qubits.The unitary simulator applies the circuit’s entire unitary matrix, while the state-vector simulator performs best locally.
- Documentation and languages: Platform usability differs in documentation and abstraction: ProjectQ has strong installation documentation but sparser remaining guidance, while QDK emphasizes hardware abstraction and high-level programming.The paper notes that simple examples may not fully represent QDK’s syntax and capabilities for algorithms involving many gates and qubits.
- Simulators: ProjectQ’s C++ simulator handles 26-qubit depth-5 circuits in under a minute and 28-qubit depth-20 circuits in just under ten minutes on the author’s computer.The maximum qubit count is limited by the user’s local memory.
- Simulators: The QDK includes a local simulator for up to 30 qubits, paid Azure access for simulations above 40 qubits, and a trace simulator for resource estimation without simulating the quantum state.The trace simulator can evaluate performance metrics for algorithms containing thousands of qubits, although documentation for the cloud route is limited.
3 Comparison
The comparison examines library support, hardware, compilers, simulators, and platform features across four quantum software platforms. Results show substantial differences in algorithm libraries, device characteristics and access, compiler behavior, and simulator performance.
- Library support: pyQuil, Qiskit, and QDK provide relatively large library support, while ProjectQ extends support through FermiLib, plugins, and OpenFermion compatibility.The QDK also includes built-in functions that automatically perform algorithms without requiring explicit circuit programming.
- Quantum hardware: Only pyQuil and Qiskit have dedicated quantum hardware, with Agave providing 8 qubits and IBMQX5 providing 16 qubits.The platforms differ in coherence times, gate fidelities, connectivity, and readout characteristics.
- Quantum hardware: IBM hardware uses queued job submission, whereas Rigetti Agave requires access approval and scheduled execution times.These access procedures represent different practical routes for running programs on real devices.
- Quantum compilers: Compiler circuit depth cannot establish superiority because each compiler targets different hardware gate sets and topologies.For example, Agave lacks direct CNOT implementation, requiring pyQuil to use Controlled-Z gates and rotations, while IBMQX5 can implement CNOT directly.
- Simulator performance: ProjectQ’s C++ simulator performed best in local testing, successfully simulating 28 qubits at depth 20 in just under ten minutes.Qiskit’s state vector simulator handled 25 qubits in just over three minutes, while circuits up to 20 qubits and depth 30 ran under five seconds.
- Platform features: The platforms offer distinct practical features, including pyQuil’s OpenFermion compatibility, Qiskit’s multilingual support and Aqua library, ProjectQ’s circuit drawer and IBM connectivity, and QDK tools for testing and resource estimation.The QDK also supports compile-time correctness checking and programming across different quantum-computation models.
4 Discussion and Conclusions
The paper offers platform-selection guidance based on programming background, learning resources, hardware access, and simulation scale. It presents these suggestions as subjective and encourages readers to choose for themselves.
- Python beginners may find Forest, Qiskit, or ProjectQ more appropriate, while C# experience may favor the Quantum Development Kit.
- Forest and Qiskit are the obvious choices for testing algorithms on real quantum computers.
- ProjectQ is recommended for simulating algorithms on a large number of qubits.
- Forest, Qiskit, and the QDK all contain good resources for learning about quantum computing.
- The suggestions are subjective, and the paper notes that additional quantum software packages are being developed.
A Cirq
The Cirq appendix reviews a Python platform for near-term quantum computing, including circuit construction, simulators, hardware-oriented tools, and documentation. Cirq supports noiseless simulation and hardware-specific workflows, but its hardware access, noisy simulation, and documentation remain limited.
- Cirq is a Python platform for working with quantum circuits on near-term quantum computers and was described for version 0.4.0 during alpha testing.
- The documentation was noticeably sparser than other platforms, especially for tutorials and examples.
- A random-bit example creates a qubit and circuit, applies a Hadamard gate, measures the qubit, and reads outcomes through a histogram.
- Cirq’s planned Foxtail and Bristlecone hardware was not yet available to general users, and the platform lacked its own quantum processor language.
- Cirq provides generic and Xmon-specific simulators for noiseless behavior, with wavefunction access for debugging.
- Cirq includes circuit optimization, automatic hardware-specific compilation, parameter sweeps, circuit drawing, and low-level schedule and device definitions.
B Other Quantum Software
The appendix briefly surveys additional quantum software, including predecessors and modern platforms outside the paper’s four main selections. These systems differ in host language, programming role, hardware support, and simulation capabilities.
- The paper’s selections were guided mainly by general-user access to real devices, alongside author experience and software release date.
- Quipper is a functional quantum language embedded in Haskell with libraries for quantum subroutines and algorithms.
- Quipper did not support connecting to quantum computers at the time, but it could simulate classical, stabilizer, and quantum circuits.
- Scaffold is a quantum programming language embedded in C that targets quantum algorithm development and can compile to OpenQASM and the QX simulator.
- QCL is presented as an early C-style quantum programming language with quantum data types, operations, and classical and quantum control flow.
- Strawberry Fields targets quantum optical circuits with continuous-variable qubits, while a general-user quantum chip had not yet been announced.
C Testing Simulator Performance
The simulator performance tests use ProjectQ’s local C++ simulator on a specified desktop system and compare it with Qiskit on an identical random circuit. The setup records runtime across qubit counts and circuit depths.
- The ProjectQ tests ran on a 64-bit Ubuntu 16.04 system with 8 GB RAM and an Intel Core i7-8550U CPU at 1.80 GHz.
- The benchmark program accepts qubit number and circuit depth as inputs, constructs a random circuit, measures all qubits, and prints runtime.
- The ProjectQ simulator uses a C++ backend with gate fusion enabled for the benchmark.
- The randomly selected circuit was also tested with the Qiskit simulator on an identical circuit.
D Example Programs: The Teleportation Circuit
The section compares teleportation-circuit programs across four quantum software languages and includes a circuit diagram generated with Qiskit’s circuit drawer.
- The examples implement quantum teleportation, sending an unknown state from one qubit to another.
- The four programs are presented side by side to compare their languages and circuit implementations.
- Quantum Developer Kit: The QDK example is only one of three programs required to run the teleportation circuit.
- The accompanying circuit diagram was produced using the circuit drawer released in Qiskit v0.5.4.
pyQuil Qiskit
The examples show how pyQuil, Qiskit, ProjectQ, and QDK express the same teleportation circuit, including state preparation, entangling operations, measurement, conditional correction, and execution.
- pyQuil: The pyQuil program constructs a three-qubit teleportation circuit with X, H, controlled-X, measurement, and conditional operations.
- Qiskit: The Qiskit program defines quantum and classical registers, builds a QuantumCircuit, and applies the teleportation gates and measurements.
- pyQuil: pyQuil measures the first two qubits, conditionally applies Z and X corrections to the third, then measures and runs the circuit on a local QASM simulator.
- Qiskit: Qiskit performs conditional corrections, executes the circuit on a local QASM simulator, retrieves counts, and can print QASM code or draw the circuit.
- ProjectQ: ProjectQ uses a MainEngine, allocates a three-qubit register, applies teleportation gates, performs controlled corrections, flushes execution, and prints the measured result.
- Quantum Developer Kit: QDK defines a Teleport operation using an auxiliary qubit, entangling gates, measurements, conditional corrections, and reset operations.