Subscribe to the gold package and get unlimited access to Shamra Academy
Register a new userQiskit Backend Specifications for OpenQASM and OpenPulse Experiments
130
0
0.0
(
0
)
Ask ChatGPT about the research
No Arabic abstract
As interest in quantum computing grows, there is a pressing need for standardized APIs so that algorithm designers, circuit designers, and physicists can be provided a common reference frame for designing, executing, and optimizing experiments. There is also a need for a language specification that goes beyond gates and allows users to specify the time dynamics of a quantum experiment and recover the time dynamics of the output. In this document we provide a specification for a common interface to backends (simulators and experiments) and a standarized data structure (Qobj --- quantum object) for sending experiments to those backends via Qiskit. We also introduce OpenPulse, a language for specifying pulse level control (i.e. control of the continuous time dynamics) of a general quantum device independent of the specific hardware implementation.
rate research
Read More
Distilling precise estimates from noisy intermediate scale quantum (NISQ) data has recently attracted considerable attention. In order to augment digital qubit metrics, such as gate fidelity, we discuss analog error mitigability, i.e. the ability to accurately distill precise observable estimates, as a hybrid quantum-classical computing benchmarking task. Specifically, we characterize single qubit error rates on IBMs Poughkeepsie superconducting quantum hardware, incorporate control-mediated noise dependence into a generalized rescaling protocol, and analyze how noise characteristics influence Richardson extrapolation-based error mitigation. Our results identify regions in the space of Hamiltonian control fields and circuit-depth which are most amenable to reliable noise extrapolation, as well as shedding light on how low-level hardware characterization can be used as a predictive tool for uncertainty quantification in error mitigated NISQ computations.
Quantum assembly languages are machine-independent languages that traditionally describe quantum computation in the circuit model. Open quantum assembly language (OpenQASM 2) was proposed as an imperative programming language for quantum circuits based on earlier QASM dialects. In principle, any quantum computation could be described using OpenQASM 2, but there is a need to describe a broader set of quantum circuits beyond the language of qubits and gates. By examining interactive use cases, we recognize two different timescales of quantum-classical interactions: real-time classical computations that must be performed within the coherence times of the qubits, and near-time computations with less stringent timing. Since the near-time domain is adequately described by existing programming frameworks, we choose in OpenQASM 3 to focus on the real-time domain, which must be more tightly coupled to the execution of quantum operations. Motivated by the need for real-time classical computation, we add support for arbitrary control flow as well as calling external classical functions. In addition, we recognize the need to describe circuits at multiple levels of specificity, and therefore we extend the language to include timing, pulse control, and gate modifiers. These new language features create a multi-level intermediate representation for circuit development and optimization, as well as control sequence implementation for calibration, characterization, and error mitigation.
Quantum computing is of high interest because it promises to perform at least some kinds of computations much faster than classical computers. Arute et al. 2019 (informally, the Google Quantum Team) report the results of experiments that purport to demonstrate quantum supremacy -- the claim that the performance of some quantum computers is better than that of classical computers on some problems. Do these results close the debate over quantum supremacy? We argue that they do not. We provide an overview of the Google Quantum Teams experiments, then identify some open questions in the quest to demonstrate quantum supremacy.
The quantum circuit model is an abstraction that hides the underlying physical implementation of gates and measurements on a quantum computer. For precise control of real quantum hardware, the ability to execute pulse and readout-level instructions is required. To that end, we introduce Qiskit Pulse, a pulse-level programming paradigm implemented as a module within Qiskit-Terra cite{Qiskit}. To demonstrate the capabilities of Qiskit Pulse, we calibrate both un-echoed and echoed variants of the cross-resonance entangling gate with a pair of qubits on an IBM Quantum system accessible through the cloud. We perform Hamiltonian characterization of both single and two-pulse variants of the cross-resonance entangling gate with varying amplitudes on a cloud-based IBM Quantum system. We then transform these calibrated sequences into a high-fidelity CNOT gate by applying pre and post local-rotations to the qubits, achieving average gate fidelities of $F=0.981$ and $F=0.979$ for the un-echoed and echoed respectively. This is comparable to the standard backend CNOT fidelity of $F_{CX}=0.984$. Furthermore, to illustrate how users can access their results at different levels of the readout chain, we build a custom discriminator to investigate qubit readout correlations. Qiskit Pulse allows users to explore advanced control schemes such as optimal control theory, dynamical decoupling, and error mitigation that are not available within the circuit model.
With the increasing rise of publicly available high level quantum computing languages, the field of Quantum Computing has reached an important milestone of separation of software from hardware. Consequently, the study of Quantum Algorithms is beginning to emerge as university courses and disciplines around the world, spanning physics, math, and computer science departments alike. As a continuation to its predecessor: Introduction to Coding Quantum Algorithms: A Tutorial Series Using Qiskit, this tutorial series aims to help understand several of the most promising quantum algorithms to date, including Phase Estimation, Shors, QAOA, VQE, and several others. Accompanying each algorithms theoretical foundations are coding examples utilizing IBMs Qiskit, demonstrating the strengths and challenges of implementing each algorithm in gate-based quantum computing.
Log in to be able to interact and post comments
comments
Fetching comments
Sign in to be able to follow your search criteria
