Release Notes

Version History

This table tracks the meta-package versions and the version of each Qiskit element installed:

Table 1 Version History

Qiskit Metapackage Version

qiskit-terra

qiskit-aer

qiskit-ignis

qiskit-ibmq-provider

qiskit-aqua

0.19.2

0.14.1

0.5.1

0.3.0

0.7.1

0.7.1

0.19.1

0.14.1

0.5.1

0.3.0

0.7.0

0.7.0

0.19.0

0.14.0

0.5.1

0.3.0

0.7.0

0.7.0

0.18.3

0.13.0

0.5.1

0.3.0

0.6.1

0.6.6

0.18.2

0.13.0

0.5.0

0.3.0

0.6.1

0.6.6

0.18.1

0.13.0

0.5.0

0.3.0

0.6.0

0.6.6

0.18.0

0.13.0

0.5.0

0.3.0

0.6.0

0.6.5

0.17.0

0.12.0

0.4.1

0.2.0

0.6.0

0.6.5

0.16.2

0.12.0

0.4.1

0.2.0

0.5.0

0.6.5

0.16.1

0.12.0

0.4.1

0.2.0

0.5.0

0.6.4

0.16.0

0.12.0

0.4.0

0.2.0

0.5.0

0.6.4

0.15.0

0.12.0

0.4.0

0.2.0

0.4.6

0.6.4

0.14.1

0.11.1

0.3.4

0.2.0

0.4.5

0.6.2

0.14.0

0.11.0

0.3.4

0.2.0

0.4.4

0.6.1

0.13.0

0.10.0

0.3.2

0.2.0

0.3.3

0.6.1

0.12.2

0.9.1

0.3.0

0.2.0

0.3.3

0.6.0

0.12.1

0.9.0

0.3.0

0.2.0

0.3.3

0.6.0

0.12.0

0.9.0

0.3.0

0.2.0

0.3.2

0.6.0

0.11.2

0.8.2

0.2.3

0.1.1

0.3.2

0.5.5

0.11.1

0.8.2

0.2.3

0.1.1

0.3.1

0.5.3

0.11.0

0.8.2

0.2.3

0.1.1

0.3.0

0.5.2

0.10.5

0.8.2

0.2.1

0.1.1

0.2.2

0.5.2

0.10.4

0.8.2

0.2.1

0.1.1

0.2.2

0.5.1

0.10.3

0.8.1

0.2.1

0.1.1

0.2.2

0.5.1

0.10.2

0.8.0

0.2.1

0.1.1

0.2.2

0.5.1

0.10.1

0.8.0

0.2.0

0.1.1

0.2.2

0.5.0

0.10.0

0.8.0

0.2.0

0.1.1

0.2.1

0.5.0

0.9.0

0.8.0

0.2.0

0.1.1

0.1.1

0.5.0

0.8.1

0.7.2

0.1.1

0.1.0

0.8.0

0.7.1

0.1.1

0.1.0

0.7.3

>=0.7,<0.8

>=0.1,<0.2

0.7.2

>=0.7,<0.8

>=0.1,<0.2

0.7.1

>=0.7,<0.8

>=0.1,<0.2

0.7.0

>=0.7,<0.8

>=0.1,<0.2

Note

For the 0.7.0, 0.7.1, and 0.7.2 meta-package releases the Versioning policy was not formalized yet.

Notable Changes

Qiskit 0.19.0

Terra 0.14.0

Prelude

The 0.14.0 release includes several new features and bug fixes. The biggest change for this release is the introduction of a quantum circuit library in qiskit.circuit.library, containing some circuit families of interest.

The circuit library gives users access to a rich set of well-studied circuit families, instances of which can be used as benchmarks, as building blocks in building more complex circuits, or as a tool to explore quantum computational advantage over classical. The contents of this library will continue to grow and mature.

The initial release of the circuit library contains:

  • standard_gates: these are fixed-width gates commonly used as primitive building blocks, consisting of 1, 2, and 3 qubit gates. For example the XGate, RZZGate and CSWAPGate. The old location of these gates under qiskit.extensions.standard is deprecated.

  • generalized_gates: these are families that can generalize to arbitrarily many qubits, for example a Permutation or GMS (Global Molmer-Sorensen gate).

  • boolean_logic: circuits that transform basis states according to simple Boolean logic functions, such as ADD or XOR.

  • arithmetic: a set of circuits for doing classical arithmetic such as WeightedAdder and IntegerComparator.

  • basis_changes: circuits such as the quantum Fourier transform, QFT, that mathematically apply basis changes.

  • n_local: patterns to easily create large circuits with rotation and entanglement layers, such as TwoLocal which uses single-qubit rotations and two-qubit entanglements.

  • data_preparation: circuits that take classical input data and encode it in a quantum state that is difficult to simulate, e.g. PauliFeatureMap or ZZFeatureMap.

  • Other circuits that have proven interesting in the literature, such as QuantumVolume, GraphState, or IQP.

To allow easier use of these circuits as building blocks, we have introduced a compose() method of qiskit.circuit.QuantumCircuit for composition of circuits either with other circuits (by welding them at the ends and optionally permuting wires) or with other simpler gates:

>>> lhs.compose(rhs, qubits=[3, 2], inplace=True)
            ┌───┐                   ┌─────┐                ┌───┐
lqr_1_0: ───┤ H ├───    rqr_0: ──■──┤ Tdg ├    lqr_1_0: ───┤ H ├───────────────
            ├───┤              ┌─┴─┐└─────┘                ├───┤
lqr_1_1: ───┤ X ├───    rqr_1: ┤ X ├───────    lqr_1_1: ───┤ X ├───────────────
         ┌──┴───┴──┐           └───┘                    ┌──┴───┴──┐┌───┐
lqr_1_2: ┤ U1(0.1) ├  +                     =  lqr_1_2: ┤ U1(0.1) ├┤ X ├───────
         └─────────┘                                    └─────────┘└─┬─┘┌─────┐
lqr_2_0: ─────■─────                           lqr_2_0: ─────■───────■──┤ Tdg ├
            ┌─┴─┐                                          ┌─┴─┐        └─────┘
lqr_2_1: ───┤ X ├───                           lqr_2_1: ───┤ X ├───────────────
            └───┘                                          └───┘
lcr_0: 0 ═══════════                           lcr_0: 0 ═══════════════════════
lcr_1: 0 ═══════════                           lcr_1: 0 ═══════════════════════

With this, Qiskit’s circuits no longer assume an implicit initial state of \(|0\rangle\), and will not be drawn with this initial state. The all-zero initial state is still assumed on a backend when a circuit is executed.

New Features
  • A new method, has_entry(), has been added to the qiskit.circuit.EquivalenceLibrary class to quickly check if a given gate has any known decompositions in the library.

  • A new class IQP, to construct an instantaneous quantum polynomial circuit, has been added to the circuit library module qiskit.circuit.library.

  • A new compose() method has been added to qiskit.circuit.QuantumCircuit. It allows composition of two quantum circuits without having to turn one into a gate or instruction. It also allows permutations of qubits/clbits at the point of composition, as well as optional inplace modification. It can also be used in place of append(), as it allows composing instructions and operators onto the circuit as well.

  • qiskit.circuit.library.Diagonal circuits have been added to the circuit library. These circuits implement diagonal quantum operators (consisting of non-zero elements only on the diagonal). They are more efficiently simulated by the Aer simulator than dense matrices.

  • Add from_label() method to the qiskit.quantum_info.Clifford class for initializing as the tensor product of single-qubit I, X, Y, Z, H, or S gates.

  • Schedule transformer qiskit.pulse.reschedule.compress_pulses() performs an optimization pass to reduce the usage of waveform memory in hardware by replacing multiple identical instances of a pulse in a pulse schedule with a single pulse. For example:

    from qiskit.pulse import reschedule
    
    schedules = []
    for _ in range(2):
        schedule = Schedule()
        drive_channel = DriveChannel(0)
        schedule += Play(SamplePulse([0.0, 0.1]), drive_channel)
        schedule += Play(SamplePulse([0.0, 0.1]), drive_channel)
        schedules.append(schedule)
    
    compressed_schedules = reschedule.compress_pulses(schedules)
    
  • The qiskit.transpiler.Layout has a new method reorder_bits() that is used to reorder a list of virtual qubits based on the layout object.

  • Two new methods have been added to the qiskit.providers.models.PulseBackendConfiguration for interacting with channels.

    • get_channel_qubits() to get a list of all qubits operated by the given channel and

    • get_qubit_channel() to get a list of channels operating on the given qubit.

  • New qiskit.extensions.HamiltonianGate and qiskit.circuit.QuantumCircuit.hamiltonian() methods are introduced, representing Hamiltonian evolution of the circuit wavefunction by a user-specified Hermitian Operator and evolution time. The evolution time can be a Parameter, allowing the creation of parameterized UCCSD or QAOA-style circuits which compile to UnitaryGate objects if time parameters are provided. The Unitary of a HamiltonianGate with Hamiltonian Operator H and time parameter t is \(e^{-iHt}\).

  • The circuit library module qiskit.circuit.library now provides a new boolean logic AND circuit, qiskit.circuit.library.AND, and OR circuit, qiskit.circuit.library.OR, which implement the respective operations on a variable number of provided qubits.

  • New fake backends are added under qiskit.test.mock. These include mocked versions of ibmq_armonk, ibmq_essex, ibmq_london, ibmq_valencia, ibmq_cambridge, ibmq_paris, ibmq_rome, and ibmq_athens. As with other fake backends, these include snapshots of calibration data (i.e. backend.defaults()) and error data (i.e. backend.properties()) taken from the real system, and can be used for local testing, compilation and simulation.

  • The last_update_date parameter for BackendProperties can now also be passed in as a datetime object. Previously only a string in ISO8601 format was accepted.

  • Adds qiskit.quantum_info.Statevector.from_int() and qiskit.quantum_info.DensityMatrix.from_int() methods that allow constructing a computational basis state for specified system dimensions.

  • The methods on the qiskit.circuit.QuantumCircuit class for adding gates (for example h()) which were previously added dynamically at run time to the class definition have been refactored to be statically defined methods of the class. This means that static analyzer (such as IDEs) can now read these methods.

Upgrade Notes
Deprecation Notes
  • The qiskit.dagcircuit.DAGCircuit.compose() method now takes a list of qubits/clbits that specify the positional order of bits to compose onto. The dictionary-based method of mapping using the edge_map argument is deprecated and will be removed in a future release.

  • The combine_into_edge_map() method for the qiskit.transpiler.Layout class has been deprecated and will be removed in a future release. Instead, the new method reorder_bits() should be used to reorder a list of virtual qubits according to the layout object.

  • Passing a qiskit.pulse.ControlChannel object in via the parameter channel for the qiskit.providers.models.PulseBackendConfiguration method control() has been deprecated and will be removed in a future release. The ControlChannel objects are now generated from the backend configuration channels attribute which has the information of all channels and the qubits they operate on. Now, the method control() is expected to take the parameter qubits of the form (control_qubit, target_qubit) and type list or tuple, and returns a list of control channels.

  • The AND and OR methods of qiskit.circuit.QuantumCircuit are deprecated and will be removed in a future release. Instead you should use the circuit library boolean logic classes qiskit.circuit.library.AND amd qiskit.circuit.library.OR and then append those objects to your class. For example:

    from qiskit import QuantumCircuit
    from qiskit.circuit.library import AND
    
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    
    qc_and = AND(2)
    
    qc.compose(qc_and, inplace=True)
    
  • The qiskit.extensions.standard module is deprecated and will be removed in a future release. The gate classes in that module have been moved to qiskit.circuit.library.standard_gates.

Bug Fixes
  • The qiskit.circuit.QuantumCircuit methods inverse(), mirror() methods, as well as the QuantumCircuit.data setter would generate an invalid circuit when used on a parameterized circuit instance. This has been resolved and these methods should now work with a parameterized circuit. Fixes #4235

  • Previously when creating a controlled version of a standard qiskit gate if a ctrl_state was specified a generic ControlledGate object would be returned whereas without it a standard qiskit controlled gate would be returned if it was defined. This PR allows standard qiskit controlled gates to understand ctrl_state.

    Additionally, this PR fixes what might be considered a bug where setting the ctrl_state of an already controlled gate would assume the specified state applied to the full control width instead of the control qubits being added. For instance,:

    circ = QuantumCircuit(2)
    circ.h(0)
    circ.x(1)
    gate = circ.to_gate()
    cgate = gate.control(1)
    c3gate = cgate.control(2, ctrl_state=0)
    

    would apply ctrl_state to all three control qubits instead of just the two control qubits being added.

  • Fixed a bug in random_clifford() that stopped it from sampling the full Clifford group. Fixes #4271

  • The qiskit.circuit.Instruction method qiskit.circuit.Instruction.is_parameterized() method had previously returned True for any Instruction instance which had a qiskit.circuit.Parameter in any element of its params array, even if that Parameter had been fully bound. This has been corrected so that .is_parameterized will return False when the instruction is fully bound.

  • qiskit.circuit.ParameterExpression.subs() had not correctly detected some cases where substituting parameters would result in a two distinct Parameters objects in an expression with the same name. This has been corrected so a CircuitError will be raised in these cases.

  • Improve performance of qiskit.quantum_info.Statevector and qiskit.quantum_info.DensityMatrix for low-qubit circuit simulations by optimizing the class __init__ methods. Fixes #4281

  • The function qiskit.compiler.transpile() now correctly handles when the parameter basis_gates is set to None. This will allow any gate in the output tranpiled circuit, including gates added by the transpilation process. Note that using this parameter may have some unintended consequences during optimization. Some transpiler passes depend on having a basis_gates set. For example, qiskit.transpiler.passes.Optimize1qGates only optimizes the chains of u1, u2, and u3 gates and without basis_gates it is unable to unroll gates that otherwise could be optimized:

    from qiskit import *
    
    q = QuantumRegister(1, name='q')
    circuit = QuantumCircuit(q)
    circuit.h(q[0])
    circuit.u1(0.1, q[0])
    circuit.u2(0.1, 0.2, q[0])
    circuit.h(q[0])
    circuit.u3(0.1, 0.2, 0.3, q[0])
    
    result = transpile(circuit, basis_gates=None, optimization_level=3)
    result.draw()
    
         ┌───┐┌─────────────┐┌───┐┌─────────────────┐
    q_0: ┤ H ├┤ U2(0.1,0.3) ├┤ H ├┤ U3(0.1,0.2,0.3) ├
         └───┘└─────────────┘└───┘└─────────────────┘
    

    Fixes #3017

Other Notes

Aer 0.5.1

No Change

Ignis 0.3.0

No Change

Aqua 0.7.0

Prelude

The Qiskit Aqua 0.7.0 release introduces a lot of new functionality along with an improved integration with qiskit.circuit.QuantumCircuit objects. The central contributions are the Qiskit’s optimization module, a complete refactor on Operators, using circuits as native input for the algorithms and removal of the declarative JSON API.

Optimization module

The qiskit.optimization` module now offers functionality for modeling and solving quadratic programs. It provides various near-term quantum and conventional algorithms, such as the MinimumEigenOptimizer (covering e.g. VQE or QAOA) or CplexOptimizer, as well as a set of converters to translate between different problem representations, such as QuadraticProgramToQubo. See the changelog for a list of the added features.

Operator flow

The operator logic provided in qiskit.aqua.operators` was completely refactored and is now a full set of tools for constructing physically-intuitive quantum computations. It contains state functions, operators and measurements and internally relies on Terra’s Operator objects. Computing expectation values and evolutions was heavily simplified and objects like the ExpectationFactory produce the suitable, most efficient expectation algorithm based on the Operator input type. See the changelog for a overview of the added functionality.

Native circuits

Algorithms commonly use parameterized circuits as input, for example the VQE, VQC or QSVM. Previously, these inputs had to be of type VariationalForm or FeatureMap which were wrapping the circuit object. Now circuits are natively supported in these algorithms, which means any individually constructed QuantumCircuit can be passed to these algorithms. In combination with the release of the circuit library which offers a wide collection of circuit families, it is now easy to construct elaborate circuits as algorithm input.

Declarative JSON API

The ability of running algorithms using dictionaries as parameters as well as using the Aqua interfaces GUI has been removed.

IBM Q Provider 0.7.0

New Features
Upgrade Notes
Deprecation Notes
Bug Fixes
  • Fixed an issue where nest_asyncio.apply() may raise an exception if there is no asyncio loop due to threading.

Qiskit 0.18.3

Terra 0.13.0

No Change

Aer 0.5.1

Upgrade Notes
  • Changes how transpilation passes are handled in the C++ Controller classes so that each pass must be explicitly called. This allows for greater customization on when each pass should be called, and with what parameters. In particular this enables setting different parameters for the gate fusion optimization pass depending on the QasmController simulation method.

  • Add gate_length_units kwarg to qiskit.providers.aer.noise.NoiseModel.from_device() for specifying custom gate_lengths in the device noise model function to handle unit conversions for internal code.

  • Add Controlled-Y (“cy”) gate to the Stabilizer simulator methods supported gateset.

  • For Aer’s backend the jsonschema validation of input qobj objects from terra is now opt-in instead of being enabled by default. If you want to enable jsonschema validation of qobj set the validate kwarg on the qiskit.providers.aer.QasmSimualtor.run() method for the backend object to True.

Bug Fixes
  • Remove “extended_stabilizer” from the automatically selected simulation methods. This is needed as the extended stabilizer method is not exact and may give incorrect results for certain circuits unless the user knows how to optimize its configuration parameters.

    The automatic method now only selects from “stabilizer”, “density_matrix”, and “statevector” methods. If a non-Clifford circuit that is too large for the statevector method is executed an exception will be raised suggesting you could try explicitly using the “extended_stabilizer” or “matrix_product_state” methods instead.

  • Fixes Controller classes so that the ReduceBarrier transpilation pass is applied first. This prevents barrier instructions from preventing truncation of unused qubits if the only instruction defined on them was a barrier.

  • Disables gate fusion for the matrix product state simulation method as this was causing issues with incorrect results being returned in some cases.

  • Fix error in gate time unit conversion for device noise model with thermal relaxation errors and gate errors. The error probability the depolarizing error was being calculated with gate time in microseconds, while for thermal relaxation it was being calculated in nanoseconds. This resulted in no depolarizing error being applied as the incorrect units would make the device seem to be coherence limited.

  • Fix bug in incorrect composition of QuantumErrors when the qubits of composed instructions differ.

  • Fix issue where the “diagonal” gate is checked to be unitary with too high a tolerance. This was causing diagonals generated from Numpy functions to often fail the test.

  • Fix remove-barrier circuit optimization pass to be applied before qubit trucation. This fixes an issue where barriers inserted by the Terra transpiler across otherwise inactive qubits would prevent them from being truncated.

Ignis 0.3.0

No Change

Aqua 0.6.6

No Change

IBM Q Provider 0.6.1

No Change

Qiskit 0.18.0

Terra 0.13.0

Prelude

The 0.13.0 release includes many big changes. Some highlights for this release are:

For the transpiler we have switched the graph library used to build the qiskit.dagcircuit.DAGCircuit class which is the underlying data structure behind all operations to be based on retworkx for greatly improved performance. Circuit transpilation speed in the 0.13.0 release should be significanlty faster than in previous releases.

There has been a significant simplification to the style in which Pulse instructions are built. Now, Command s are deprecated and a unified set of Instruction s are supported.

The qiskit.quantum_info module includes several new functions for generating random operators (such as Cliffords and quantum channels) and for computing the diamond norm of quantum channels; upgrades to the Statevector and DensityMatrix classes to support computing measurement probabilities and sampling measurements; and several new classes are based on the symplectic representation of Pauli matrices. These new classes include Clifford operators (Clifford), N-qubit matrices that are sparse in the Pauli basis (SparsePauliOp), lists of Pauli’s (PauliTable), and lists of stabilizers (StabilizerTable).

This release also has vastly improved documentation across Qiskit, including improved documentation for the qiskit.circuit, qiskit.pulse and qiskit.quantum_info modules.

Additionally, the naming of gate objects and QuantumCircuit methods have been updated to be more consistent. This has resulted in several classes and methods being deprecated as things move to a more consistent naming scheme.

For full details on all the changes made in this release see the detailed release notes below.

New Features
  • Added a new circuit library module qiskit.circuit.library. This will be a place for constructors of commonly used circuits that can be used as building blocks for larger circuits or applications.

  • The qiskit.providers.BaseJob class has four new methods:

    These methods are used to check wheter a job is in a given job status.

  • Add ability to specify control conditioned on a qubit being in the ground state. The state of the control qubits is represented by an integer. For example:

    from qiskit import QuantumCircuit
    from qiskit.extensions.standard import XGate
    
    qc = QuantumCircuit(4)
    cgate = XGate().control(3, ctrl_state=6)
    qc.append(cgate, [0, 1, 2, 3])
    

    Creates a four qubit gate where the fourth qubit gets flipped if the first qubit is in the ground state and the second and third qubits are in the excited state. If ctrl_state is None, the default, control is conditioned on all control qubits being excited.

  • A new jupyter widget, %circuit_library_info has been added to qiskit.tools.jupyter. This widget is used for visualizing details about circuits built from the circuit library. For example

    from qiskit.circuit.library import XOR
    import qiskit.tools.jupyter
    circuit = XOR(5, seed=42)
    %circuit_library_info circuit
    
    _images/release_notes_0_0.png
  • A new kwarg option, formatted , has been added to qiskit.circuit.QuantumCircuit.qasm() . When set to True the the method will print a syntax highlighted version (using pygments) to stdout and return None (which differs from the normal behavior of returning the QASM code as a string).

  • A new kwarg option, filename , has been added to qiskit.circuit.QuantumCircuit.qasm(). When set to a path the method will write the QASM code to that file. It will then continue to output as normal.

  • A new instruction SetFrequency which allows users to change the frequency of the PulseChannel. This is done in the following way:

    from qiskit.pulse import Schedule
    from qiskit.pulse import SetFrequency
    
    sched = pulse.Schedule()
    sched += SetFrequency(5.5e9, DriveChannel(0))
    

    In this example, the frequency of all pulses before the SetFrequency command will be the default frequency and all pulses applied to drive channel zero after the SetFrequency command will be at 5.5 GHz. Users of SetFrequency should keep in mind any hardware limitations.

  • A new method, assign_parameters() has been added to the qiskit.circuit.QuantumCircuit class. This method accepts a parameter dictionary with both floats and Parameters objects in a single dictionary. In other words this new method allows you to bind floats, Parameters or both in a single dictionary.

    Also, by using the inplace kwarg it can be specified you can optionally modify the original circuit in place. By default this is set to False and a copy of the original circuit will be returned from the method.

  • A new method num_nonlocal_gates() has been added to the qiskit.circuit.QuantumCircuit class. This method will return the number of gates in a circuit that involve 2 or or more qubits. These gates are more costly in terms of time and error to implement.

  • The qiskit.circuit.QuantumCircuit method iso() for adding an Isometry gate to the circuit has a new alias. You can now call qiskit.circuit.QuantumCircuit.isometry() in addition to calling iso.

  • A description attribute has been added to the CouplingMap class for storing a short description for different coupling maps (e.g. full, grid, line, etc.).

  • A new method compose() has been added to the DAGCircuit class for composing two circuits via their DAGs.

    dag_left.compose(dag_right, edge_map={right_qubit0: self.left_qubit1,
                                      right_qubit1: self.left_qubit4,
                                      right_clbit0: self.left_clbit1,
                                      right_clbit1: self.left_clbit0})
    
                ┌───┐                    ┌─────┐┌─┐
    lqr_1_0: ───┤ H ├───     rqr_0: ──■──┤ Tdg ├┤M├
                ├───┤               ┌─┴─┐└─┬─┬─┘└╥┘
    lqr_1_1: ───┤ X ├───     rqr_1: ┤ X ├──┤M├───╫─
             ┌──┴───┴──┐            └───┘  └╥┘   ║
    lqr_1_2: ┤ U1(0.1) ├  +  rcr_0: ════════╬════╩═  =
             └─────────┘                    ║
    lqr_2_0: ─────■─────     rcr_1: ════════╩══════
                ┌─┴─┐
    lqr_2_1: ───┤ X ├───
                └───┘
    lcr_0:   ═══════════
    
    lcr_1:   ═══════════
    
                ┌───┐
    lqr_1_0: ───┤ H ├──────────────────
                ├───┤        ┌─────┐┌─┐
    lqr_1_1: ───┤ X ├─────■──┤ Tdg ├┤M├
             ┌──┴───┴──┐  │  └─────┘└╥┘
    lqr_1_2: ┤ U1(0.1) ├──┼──────────╫─
             └─────────┘  │          ║
    lqr_2_0: ─────■───────┼──────────╫─
                ┌─┴─┐   ┌─┴─┐  ┌─┐   ║
    lqr_2_1: ───┤ X ├───┤ X ├──┤M├───╫─
                └───┘   └───┘  └╥┘   ║
    lcr_0:   ═══════════════════╩════╬═
                                     ║
    lcr_1:   ════════════════════════╩═
    
  • The mock backends in qiskit.test.mock now have a functional run() method that will return results similar to the real devices. If qiskit-aer is installed a simulation will be run with a noise model built from the device snapshot in the fake backend. Otherwise, qiskit.providers.basicaer.QasmSimulatorPy will be used to run an ideal simulation. Additionally, if a pulse experiment is passed to run and qiskit-aer is installed the PulseSimulator will be used to simulate the pulse schedules.

  • The qiskit.result.Result() method get_counts() will now return a list of all the counts available when there are multiple circuits in a job. This works when get_counts() is called with no arguments.

    The main consideration for this feature was for drawing all the results from multiple circuits in the same histogram. For example it is now possible to do something like:

    from qiskit import execute
    from qiskit import QuantumCircuit
    from qiskit.providers.basicaer import BasicAer
    from qiskit.visualization import plot_histogram
    
    sim = BasicAer.get_backend('qasm_simulator')
    
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    qc.measure_all()
    result = execute([qc, qc, qc], sim).result()
    
    plot_histogram(result.get_counts())
    
    _images/release_notes_1_0.png
  • A new kwarg, initial_state has been added to the qiskit.visualization.circuit_drawer() function and the QuantumCircuit method draw(). When set to True the initial state will be included in circuit visualizations for all backends. For example:

    from qiskit import QuantumCircuit
    
    circuit = QuantumCircuit(2)
    circuit.measure_all()
    circuit.draw(output='mpl', initial_state=True)
    
    _images/release_notes_2_0.png
  • It is now possible to insert a callable into a qiskit.pulse.InstructionScheduleMap which returns a new qiskit.pulse.Schedule when it is called with parameters. For example:

    def test_func(x):
       sched = Schedule()
       sched += pulse_lib.constant(int(x), amp_test)(DriveChannel(0))
       return sched
    
    inst_map = InstructionScheduleMap()
    inst_map.add('f', (0,), test_func)
    output_sched = inst_map.get('f', (0,), 10)
    assert output_sched.duration == 10
    
  • Two new gate classes, qiskit.extensions.iSwapGate and qiskit.extensions.DCXGate, along with their QuantumCircuit methods iswap() and dcx() have been added to the standard extensions. These gates, which are locally equivalent to each other, can be used to enact particular XY interactions. A brief motivation for these gates can be found in: arxiv.org/abs/quant-ph/0209035

  • The qiskit.providers.BaseJob class now has a new method wait_for_final_state() that polls for the job status until the job reaches a final state (such as DONE or ERROR). This method also takes an optional callback kwarg which takes a Python callable that will be called during each iteration of the poll loop.

  • The search_width and search_depth attributes of the qiskit.transpiler.passes.LookaheadSwap pass are now settable when initializing the pass. A larger search space can often lead to more optimized circuits, at the cost of longer run time.

  • The number of qubits in BackendConfiguration can now be accessed via the property num_qubits. It was previously only accessible via the n_qubits attribute.

  • Two new methods, angles() and angles_and_phase(), have been added to the qiskit.quantum_info.OneQubitEulerDecomposer class. These methods will return the relevant parameters without validation, and calling the OneQubitEulerDecomposer object will perform the full synthesis with validation.

  • An RR decomposition basis has been added to the qiskit.quantum_info.OneQubitEulerDecomposer for decomposing an arbitrary 2x2 unitary into a two RGate circuit.

  • Adds the ability to set qargs to objects which are subclasses of the abstract BaseOperator class. This is done by calling the object op(qargs) (where op is an operator class) and will return a shallow copy of the original object with a qargs property set. When such an object is used with the compose() or dot() methods the internal value for qargs will be used when the qargs method kwarg is not used. This allows for subsystem composition using binary operators, for example:

    from qiskit.quantum_info import Operator
    
    init = Operator.from_label('III')
    x = Operator.from_label('X')
    h = Operator.from_label('H')
    init @ x([0]) @ h([1])
    
  • Adds qiskit.quantum_info.Clifford operator class to the quantum_info module. This operator is an efficient symplectic representation an N-qubit unitary operator from the Clifford group. This class includes a to_circuit() method for compilation into a QuantumCircuit of Clifford gates with a minimal number of CX gates for up to 3-qubits. It also providers general compilation for N > 3 qubits but this method is not optimal in the number of two-qubit gates.

  • Adds qiskit.quantum_info.SparsePauliOp operator class. This is an efficient representaiton of an N-qubit matrix that is sparse in the Pauli basis and uses a qiskit.quantum_info.PauliTable and vector of complex coefficients for its data structure.

    This class supports much of the same functionality of the qiskit.quantum_info.Operator class so SparsePauliOp objects can be tensored, composed, scalar multiplied, added and subtracted.

    Numpy arrays or Operator objects can be converted to a SparsePauliOp using the :class:`~qiskit.quantum_info.SparsePauliOp.from_operator method. SparsePauliOp can be convered to a sparse csr_matrix or dense Numpy array using the to_matrix method, or to an Operator object using the to_operator method.

    A SparsePauliOp can be iterated over in terms of its PauliTable components and coefficients, its coefficients and Pauli string labels using the label_iter() method, and the (dense or sparse) matrix components using the matrix_iter() method.

  • Add qiskit.quantum_info.diamond_norm() function for computing the diamond norm (completely-bounded trace-norm) of a quantum channel. This can be used to compute the distance between two quantum channels using diamond_norm(chan1 - chan2).

  • A new class qiskit.quantum_info.PauliTable has been added. This is an efficient symplectic representation of a list of N-qubit Pauli operators. Some features of this class are:

    • PauliTable objects may be composed, and tensored which will return a PauliTable object with the combination of the operation ( compose(), dot(), expand(), tensor()) between each element of the first table, with each element of the second table.

    • Addition of two tables acts as list concatination of the terms in each table (+).

    • Pauli tables can be sorted by lexicographic (tensor product) order or by Pauli weights (sort()).

    • Duplicate elements can be counted and deleted (unique()).

    • The PauliTable may be iterated over in either its native symplectic boolean array representation, as Pauli string labels (label_iter()), or as dense Numpy array or sparse CSR matrices (matrix_iter()).

    • Checking commutation between elements of the Pauli table and another Pauli (commutes()) or Pauli table (commutes_with_all())

    See the qiskit.quantum_info.PauliTable class API documentation for additional details.

  • Adds qiskit.quantum_info.StabilizerTable class. This is a subclass of the qiskit.quantum_info.PauliTable class which includes a boolean phase vector along with the Pauli table array. This represents a list of Stabilizer operators which are real-Pauli operators with +1 or -1 coefficient. Because the stabilizer matrices are real the "Y" label matrix is defined as [[0, 1], [-1, 0]]. See the API documentation for additional information.

  • Adds qiskit.quantum_info.pauli_basis() function which returns an N-qubit Pauli basis as a qiskit.quantum_info.PauliTable object. The ordering of this basis can either be by standard lexicographic (tensor product) order, or by the number of non-identity Pauli terms (weight).

  • Adds qiskit.quantum_info.ScalarOp operator class that represents a scalar multiple of an identity operator. This can be used to initialize an identity on arbitrary dimension subsystems and it will be implicitly converted to other BaseOperator subclasses (such as an qiskit.quantum_info.Operator or qiskit.quantum_info.SuperOp) when it is composed with, or added to, them.

    Example: Identity operator

    from qiskit.quantum_info import ScalarOp, Operator
    
    X = Operator.from_label('X')
    Z = Operator.from_label('Z')
    
    init = ScalarOp(2 ** 3)  # 3-qubit identity
    op = init @ X([0]) @ Z([1]) @ X([2])  # Op XZX
    
  • A new method, reshape(), has been added to the qiskit.quantum_innfo.Operator class that returns a shallow copy of an operator subclass with reshaped subsystem input or output dimensions. The combined dimensions of all subsystems must be the same as the original operator or an exception will be raised.

  • Adds qiskit.quantum_info.random_clifford() for generating a random qiskit.quantum_info.Clifford operator.

  • Add qiskit.quantum_info.random_quantum_channel() function for generating a random quantum channel with fixed Choi-rank in the Stinespring representation.

  • Add qiskit.quantum_info.random_hermitian() for generating a random Hermitian Operator.

  • Add qiskit.quantum_info.random_statevector() for generating a random Statevector.

  • Adds qiskit.quantum_info.random_pauli_table() for generating a random qiskit.quantum_info.PauliTable.

  • Adds qiskit.quantum_info.random_stabilizer_table() for generating a random qiskit.quantum_info.StabilizerTable.

  • Add a num_qubits attribute to qiskit.quantum_info.StateVector and qiskit.quantum_info.DensityMatrix classes. This returns the number of qubits for N-qubit states and returns None for non-qubit states.

  • Adds to_dict() and to_dict() methods to convert qiskit.quantum_info.Statevector and qiskit.quantum_info.DensityMatrix objects into Bra-Ket notation dictionary.

    Example

    from qiskit.quantum_info import Statevector
    
    state = Statevector.from_label('+0')
    print(state.to_dict())
    
    {'00': (0.7071067811865475+0j), '10': (0.7071067811865475+0j)}
    
    from qiskit.quantum_info import DensityMatrix
    
    state = DensityMatrix.from_label('+0')
    print(state.to_dict())
    
    {'00|00': (0.4999999999999999+0j), '10|00': (0.4999999999999999+0j), '00|10': (0.4999999999999999+0j), '10|10': (0.4999999999999999+0j)}
    
  • Adds probabilities() and probabilities() to qiskit.quantum_info.Statevector and qiskit.quantum_info.DensityMatrix classes which return an array of measurement outcome probabilities in the computational basis for the specified subsystems.

    Example

    from qiskit.quantum_info import Statevector
    
    state = Statevector.from_label('+0')
    print(state.probabilities())
    
    [0.5 0.  0.5 0. ]
    
    from qiskit.quantum_info import DensityMatrix
    
    state = DensityMatrix.from_label('+0')
    print(state.probabilities())
    
    [0.5 0.  0.5 0. ]
    
  • Adds probabilities_dict() and probabilities_dict() to qiskit.quantum_info.Statevector and qiskit.quantum_info.DensityMatrix classes which return a count-style dictionary array of measurement outcome probabilities in the computational basis for the specified subsystems.

    from qiskit.quantum_info import Statevector
    
    state = Statevector.from_label('+0')
    print(state.probabilities_dict())
    
    {'00': 0.4999999999999999, '10': 0.4999999999999999}
    
    from qiskit.quantum_info import DensityMatrix
    
    state = DensityMatrix.from_label('+0')
    print(state.probabilities_dict())
    
    {'00': 0.4999999999999999, '10': 0.4999999999999999}
    
  • Add sample_counts() and sample_memory() methods to the Statevector and DensityMatrix classes for sampling measurement outcomes on subsystems.

    Example:

    Generate a counts dictionary by sampling from a statevector

    from qiskit.quantum_info import Statevector
    
    psi = Statevector.from_label('+0')
    shots = 1024
    
    # Sample counts dictionary
    counts = psi.sample_counts(shots)
    print('Measure both:', counts)
    
    # Qubit-0
    counts0 = psi.sample_counts(shots, [0])
    print('Measure Qubit-0:', counts0)
    
    # Qubit-1
    counts1 = psi.sample_counts(shots, [1])
    print('Measure Qubit-1:', counts1)
    
    Measure both: {'00': 506, '10': 518}
    Measure Qubit-0: {'0': 1024}
    Measure Qubit-1: {'0': 504, '1': 520}
    

    Return the array of measurement outcomes for each sample

    from qiskit.quantum_info import Statevector
    
    psi = Statevector.from_label('-1')
    shots = 10
    
    # Sample memory
    mem = psi.sample_memory(shots)
    print('Measure both:', mem)
    
    # Qubit-0
    mem0 = psi.sample_memory(shots, [0])
    print('Measure Qubit-0:', mem0)
    
    # Qubit-1
    mem1 = psi.sample_memory(shots, [1])
    print('Measure Qubit-1:', mem1)
    
    Measure both: ['01' '01' '11' '11' '11' '01' '11' '11' '11' '01']
    Measure Qubit-0: ['1' '1' '1' '1' '1' '1' '1' '1' '1' '1']
    Measure Qubit-1: ['1' '0' '1' '0' '0' '0' '0' '0' '1' '0']
    
  • Adds a measure() method to the qiskit.quantum_info.Statevector and qiskit.quantum_info.DensityMatrix quantum state classes. This allows sampling a single measurement outcome from the specified subsystems and collapsing the statevector to the post-measurement computational basis state. For example

    from qiskit.quantum_info import Statevector
    
    psi = Statevector.from_label('+1')
    
    # Measure both qubits
    outcome, psi_meas = psi.measure()
    print("measure([0, 1]) outcome:", outcome, "Post-measurement state:")
    print(psi_meas)
    
    # Measure qubit-1 only
    outcome, psi_meas = psi.measure([1])
    print("measure([1]) outcome:", outcome, "Post-measurement state:")
    print(psi_meas)
    
    measure([0, 1]) outcome: 11 Post-measurement state:
    Statevector([0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
                dims=(2, 2))
    measure([1]) outcome: 0 Post-measurement state:
    Statevector([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
                dims=(2, 2))
    
  • Adds a reset() method to the qiskit.quantum_info.Statevector and qiskit.quantum_info.DensityMatrix quantum state classes. This allows reseting some or all subsystems to the \(|0\rangle\) state. For example

    from qiskit.quantum_info import Statevector
    
    psi = Statevector.from_label('+1')
    
    # Reset both qubits
    psi_reset = psi.reset()
    print("Post reset state: ")
    print(psi_reset)
    
    # Reset qubit-1 only
    psi_reset = psi.reset([1])
    print("Post reset([1]) state: ")
    print(psi_reset)
    
    Post reset state: 
    Statevector([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
                dims=(2, 2))
    Post reset([1]) state: 
    Statevector([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
                dims=(2, 2))
    
  • A new visualization function qiskit.visualization.visualize_transition() for visualizing single qubit gate transitions has been added. It takes in a single qubit circuit and returns an animation of qubit state transitions on a Bloch sphere. To use this function you must have installed the dependencies for and configured globally a matplotlib animtion writer. You can refer to the matplotlib documentation for more details on this. However, in the default case simply ensuring that FFmpeg is installed is sufficient to use this function.

    It supports circuits with the following gates:

    • HGate

    • XGate

    • YGate

    • ZGate

    • RXGate

    • RYGate

    • RZGate

    • SGate

    • SdgGate

    • TGate

    • TdgGate

    • U1Gate

    For example:

    from qiskit.visualization import visualize_transition
    from qiskit import *
    
    qc = QuantumCircuit(1)
    qc.h(0)
    qc.ry(70,0)
    qc.rx(90,0)
    qc.rz(120,0)
    
    visualize_transition(qc, fpg=20, spg=1, trace=True)