613 lines
40 KiB
Plaintext
613 lines
40 KiB
Plaintext
---
|
||
title: Qiskit 0.12 release notes
|
||
description: Changes made in Qiskit 0.12
|
||
in_page_toc_max_heading_level: 4
|
||
---
|
||
|
||
# Qiskit 0.12 release notes
|
||
|
||
## 0.12.0
|
||
|
||
<span id="terra-0-9" />
|
||
|
||
<span id="release-notes-0-9-0" />
|
||
|
||
### Terra 0.9
|
||
|
||
<span id="release-notes-0-9-0-prelude" />
|
||
|
||
<span id="id551" />
|
||
|
||
#### Prelude
|
||
|
||
The 0.9 release includes many new features and many bug fixes. The biggest changes for this release are new debugging capabilities for PassManagers. This includes a function to visualize a PassManager, the ability to add a callback function to a PassManager, and logging of passes run in the PassManager. Additionally, this release standardizes the way that you can set an initial layout for your circuit. So now you can leverage `initial_layout` the kwarg parameter on `qiskit.compiler.transpile()` and `qiskit.execute()` and the qubits in the circuit will get laid out on the desire qubits on the device. Visualization of circuits will now also show this clearly when visualizing a circuit that has been transpiled with a layout.
|
||
|
||
<span id="release-notes-0-9-0-new-features" />
|
||
|
||
<span id="id552" />
|
||
|
||
#### New Features
|
||
|
||
* A `DAGCircuit` object (i.e. the graph representation of a QuantumCircuit where operation dependencies are explicit) can now be visualized with the `.draw()` method. This is in line with Qiskit’s philosophy of easy visualization. Other objects which support a `.draw()` method are `QuantumCircuit`, `PassManager`, and `Schedule`.
|
||
|
||
* Added a new visualization function `qiskit.visualization.plot_error_map()` to plot the error map for a given backend. It takes in a backend object from the qiskit-ibmq-provider and will plot the current error map for that device.
|
||
|
||
* Both `qiskit.QuantumCircuit.draw()` and `qiskit.visualization.circuit_drawer()` now support annotating the qubits in the visualization with layout information. If the `QuantumCircuit` object being drawn includes layout metadata (which is normally only set on the circuit output from `transpile()` calls) then by default that layout will be shown on the diagram. This is done for all circuit drawer backends. For example:
|
||
|
||
```python
|
||
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
|
||
from qiskit.compiler import transpile
|
||
|
||
qr = QuantumRegister(2, 'userqr')
|
||
cr = ClassicalRegister(2, 'c0')
|
||
qc = QuantumCircuit(qr, cr)
|
||
qc.h(qr[0])
|
||
qc.cx(qr[0], qr[1])
|
||
qc.y(qr[0])
|
||
qc.x(qr[1])
|
||
qc.measure(qr, cr)
|
||
|
||
# Melbourne coupling map
|
||
coupling_map = [[1, 0], [1, 2], [2, 3], [4, 3], [4, 10], [5, 4],
|
||
[5, 6], [5, 9], [6, 8], [7, 8], [9, 8], [9, 10],
|
||
[11, 3], [11, 10], [11, 12], [12, 2], [13, 1],
|
||
[13, 12]]
|
||
qc_result = transpile(qc, basis_gates=['u1', 'u2', 'u3', 'cx', 'id'],
|
||
coupling_map=coupling_map, optimization_level=0)
|
||
qc.draw(output='text')
|
||
```
|
||
|
||
will yield a diagram like:
|
||
|
||
```python
|
||
┌──────────┐┌──────────┐┌───┐┌──────────┐┌──────────────────┐┌─┐
|
||
(userqr0) q0|0>┤ U2(0,pi) ├┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├┤ U3(pi,pi/2,pi/2) ├┤M├───
|
||
├──────────┤└──────────┘└─┬─┘├──────────┤└─┬─────────────┬──┘└╥┘┌─┐
|
||
(userqr1) q1|0>┤ U2(0,pi) ├──────────────■──┤ U2(0,pi) ├──┤ U3(pi,0,pi) ├────╫─┤M├
|
||
└──────────┘ └──────────┘ └─────────────┘ ║ └╥┘
|
||
(ancilla0) q2|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla1) q3|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla2) q4|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla3) q5|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla4) q6|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla5) q7|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla6) q8|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla7) q9|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla8) q10|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla9) q11|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla10) q12|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
(ancilla11) q13|0>──────────────────────────────────────────────────────────────╫──╫─
|
||
║ ║
|
||
c0_0: 0 ══════════════════════════════════════════════════════════════╩══╬═
|
||
║
|
||
c0_1: 0 ═════════════════════════════════════════════════════════════════╩═
|
||
```
|
||
|
||
If you do not want the layout to be shown on transpiled circuits (or any other circuits with a layout set) there is a new boolean kwarg for both functions, `with_layout` (which defaults `True`), which when set `False` will disable the layout annotation in the output circuits.
|
||
|
||
* A new analysis pass `CountOpsLongest` was added to retrieve the number of operations on the longest path of the DAGCircuit. When used it will add a `count_ops_longest_path` key to the property set dictionary. You can add it to your a passmanager with something like:
|
||
|
||
```python
|
||
from qiskit.transpiler.passes import CountOpsLongestPath
|
||
from qiskit.transpiler.passes import CxCancellation
|
||
from qiskit.transpiler import PassManager
|
||
|
||
pm = PassManager()
|
||
pm.append(CountOpsLongestPath())
|
||
```
|
||
|
||
and then access the longest path via the property set value with something like:
|
||
|
||
```python
|
||
pm.append(
|
||
CxCancellation(),
|
||
condition=lambda property_set: property_set[
|
||
'count_ops_longest_path'] < 5)
|
||
```
|
||
|
||
which will set a condition on that pass based on the longest path.
|
||
|
||
* Two new functions, `sech()` and `sech_deriv()` were added to the pulse library module `qiskit.pulse.pulse_lib` for creating an unnormalized hyperbolic secant `SamplePulse` object and an unnormalized hyperbolic secant derviative `SamplePulse` object respectively.
|
||
|
||
* A new kwarg option `vertical_compression` was added to the `QuantumCircuit.draw()` method and the `qiskit.visualization.circuit_drawer()` function. This option only works with the `text` backend. This option can be set to either `high`, `medium` (the default), or `low` to adjust how much vertical space is used by the output visualization.
|
||
|
||
* A new kwarg boolean option `idle_wires` was added to the `QuantumCircuit.draw()` method and the `qiskit.visualization.circuit_drawer()` function. It works for all drawer backends. When `idle_wires` is set False in a drawer call the drawer will not draw any bits that do not have any circuit elements in the output quantum circuit visualization.
|
||
|
||
* A new PassManager visualizer function `qiskit.visualization.pass_mamanger_drawer()` was added. This function takes in a PassManager object and will generate a flow control diagram of all the passes run in the PassManager.
|
||
|
||
* When creating a PassManager you can now specify a callback function that if specified will be run after each pass is executed. This function gets passed a set of kwargs on each call with the state of the pass manager after each pass execution. Currently these kwargs are:
|
||
|
||
* `pass_` (`Pass`): the pass being run
|
||
* `dag` (`DAGCircuit`): the dag output of the pass
|
||
* `time` (`float`): the time to execute the pass
|
||
* `property_set` (`PropertySet`): the property set
|
||
* `count` (`int`): the index for the pass execution
|
||
|
||
However, it’s worth noting that while these arguments are set for the 0.9 release they expose the internals of the pass manager and are subject to change in future release.
|
||
|
||
For example you can use this to create a callback function that will visualize the circuit output after each pass is executed:
|
||
|
||
```python
|
||
from qiskit.transpiler import PassManager
|
||
|
||
def my_callback(**kwargs):
|
||
print(kwargs['dag'])
|
||
|
||
pm = PassManager(callback=my_callback)
|
||
```
|
||
|
||
Additionally you can specify the callback function when using `qiskit.compiler.transpile()`:
|
||
|
||
```python
|
||
from qiskit.compiler import transpile
|
||
|
||
def my_callback(**kwargs):
|
||
print(kwargs['pass'])
|
||
|
||
transpile(circ, callback=my_callback)
|
||
```
|
||
|
||
* A new method `filter()` was added to the `qiskit.pulse.Schedule` class. This enables filtering the instructions in a schedule. For example, filtering by instruction type:
|
||
|
||
```python
|
||
from qiskit.pulse import Schedule
|
||
from qiskit.pulse.commands import Acquire
|
||
from qiskit.pulse.commands import AcquireInstruction
|
||
from qiskit.pulse.commands import FrameChange
|
||
|
||
sched = Schedule(name='MyExperiment')
|
||
sched.insert(0, FrameChange(phase=-1.57)(device))
|
||
sched.insert(60, Acquire(5))
|
||
acquire_sched = sched.filter(instruction_types=[AcquireInstruction])
|
||
```
|
||
|
||
* Additional decomposition methods for several types of gates. These methods will use different decomposition techniques to break down a gate into a sequence of CNOTs and single qubit gates. The following methods are added:
|
||
|
||
| Method | Description |
|
||
| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||
| `QuantumCircuit.iso()` | Add an arbitrary isometry from m to n qubits to a circuit. This allows for attaching arbitrary unitaries on n qubits (m=n) or to prepare any state of n qubits (m=0) |
|
||
| `QuantumCircuit.diag_gate()` | Add a diagonal gate to the circuit |
|
||
| `QuantumCircuit.squ()` | Decompose an arbitrary 2x2 unitary into three rotation gates and add to a circuit |
|
||
| `QuantumCircuit.ucg()` | Attach an uniformly controlled gate (also called a multiplexed gate) to a circuit |
|
||
| `QuantumCircuit.ucx()` | Attach a uniformly controlled (also called multiplexed) Rx rotation gate to a circuit |
|
||
| `QuantumCircuit.ucy()` | Attach a uniformly controlled (also called multiplexed) Ry rotation gate to a circuit |
|
||
| `QuantumCircuit.ucz()` | Attach a uniformly controlled (also called multiplexed) Rz rotation gate to a circuit |
|
||
|
||
* Addition of Gray-Synth and Patel–Markov–Hayes algorithms for synthesis of CNOT-Phase and CNOT-only linear circuits. These functions allow the synthesis of circuits that consist of only CNOT gates given a linear function or a circuit that consists of only CNOT and phase gates given a matrix description.
|
||
|
||
* A new function `random_circuit` was added to the `qiskit.circuit.random` module. This function will generate a random circuit of a specified size by randomly selecting different gates and adding them to the circuit. For example, you can use this to generate a 5-qubit circuit with a depth of 10 using:
|
||
|
||
```python
|
||
from qiskit.circuit.random import random_circuit
|
||
|
||
circ = random_circuit(5, 10)
|
||
```
|
||
|
||
* A new kwarg `output_names` was added to the `qiskit.compiler.transpile()` function. This kwarg takes in a string or a list of strings and uses those as the value of the circuit name for the output circuits that get returned by the `transpile()` call. For example:
|
||
|
||
```python
|
||
from qiskit.compiler import transpile
|
||
my_circs = [circ_a, circ_b]
|
||
tcirc_a, tcirc_b = transpile(my_circs,
|
||
output_names=['Circuit A', 'Circuit B'])
|
||
```
|
||
|
||
the `name` attribute on tcirc\_a and tcirc\_b will be `'Circuit A'` and `'Circuit B'` respectively.
|
||
|
||
* A new method `equiv()` was added to the `qiskit.quantum_info.Operator` and `qiskit.quantum_info.Statevector` classes. These methods are used to check whether a second `Operator` object or `Statevector` is equivalent up to global phase.
|
||
|
||
* The user config file has several new options:
|
||
|
||
* The `circuit_drawer` field now accepts an auto value. When set as the value for the `circuit_drawer` field the default drawer backend will be mpl if it is available, otherwise the text backend will be used.
|
||
* A new field `circuit_mpl_style` can be used to set the default style used by the matplotlib circuit drawer. Valid values for this field are `bw` and `default` to set the default to a black and white or the default color style respectively.
|
||
* A new field `transpile_optimization_level` can be used to set the default transpiler optimization level to use for calls to `qiskit.compiler.transpile()`. The value can be set to either 0, 1, 2, or 3.
|
||
|
||
* Introduced a new pulse command `Delay` which may be inserted into a pulse `Schedule`. This command accepts a `duration` and may be added to any `Channel`. Other commands may not be scheduled on a channel during a delay.
|
||
|
||
The delay can be added just like any other pulse command. For example:
|
||
|
||
```python
|
||
from qiskit import pulse
|
||
|
||
drive_channel = pulse.DriveChannel(0)
|
||
delay = pulse.Delay(20)
|
||
|
||
sched = pulse.Schedule()
|
||
sched += delay(drive_channel)
|
||
```
|
||
|
||
<span id="release-notes-0-9-0-upgrade-notes" />
|
||
|
||
<span id="id553" />
|
||
|
||
#### Upgrade Notes
|
||
|
||
* The previously deprecated `qiskit._util` module has been removed. `qiskit.util` should be used instead.
|
||
|
||
* The `QuantumCircuit.count_ops()` method now returns an `OrderedDict` object instead of a `dict`. This should be compatible for most use cases since `OrderedDict` is a `dict` subclass. However type checks and other class checks might need to be updated.
|
||
|
||
* The `DAGCircuit.width()` method now returns the total number quantum bits and classical bits. Before it would only return the number of quantum bits. If you require just the number of quantum bits you can use `DAGCircuit.num_qubits()` instead.
|
||
|
||
* The function `DAGCircuit.num_cbits()` has been removed. Instead you can use `DAGCircuit.num_clbits()`.
|
||
|
||
* Individual quantum bits and classical bits are no longer represented as `(register, index)` tuples. They are now instances of Qubit and Clbit classes. If you’re dealing with individual bits make sure that you update any usage or type checks to look for these new classes instead of tuples.
|
||
|
||
* The preset passmanager classes `qiskit.transpiler.preset_passmanagers.default_pass_manager` and `qiskit.transpiler.preset_passmanagers.default_pass_manager_simulator` (which were the previous default pass managers for `qiskit.compiler.transpile()` calls) have been removed. If you were manually using this pass managers switch to the new default, `qiskit.transpile.preset_passmanagers.level1_pass_manager`.
|
||
|
||
* The `LegacySwap` pass has been removed. If you were using it in a custom pass manager, it’s usage can be replaced by the `StochasticSwap` pass, which is a faster more stable version. All the preset passmanagers have been updated to use `StochasticSwap` pass instead of the `LegacySwap`.
|
||
|
||
* The following deprecated `qiskit.dagcircuit.DAGCircuit` methods have been removed:
|
||
|
||
* `DAGCircuit.get_qubits()` - Use `DAGCircuit.qubits()` instead
|
||
|
||
* `DAGCircuit.get_bits()` - Use `DAGCircuit.clbits()` instead
|
||
|
||
* `DAGCircuit.qasm()` - Use a combination of `qiskit.converters.dag_to_circuit()` and `QuantumCircuit.qasm()`. For example:
|
||
|
||
```python
|
||
from qiskit.dagcircuit import DAGCircuit
|
||
from qiskit.converters import dag_to_circuit
|
||
my_dag = DAGCircuit()
|
||
qasm = dag_to_circuit(my_dag).qasm()
|
||
```
|
||
|
||
* `DAGCircuit.get_op_nodes()` - Use `DAGCircuit.op_nodes()` instead. Note that the return type is a list of `DAGNode` objects for `op_nodes()` instead of the list of tuples previously returned by `get_op_nodes()`.
|
||
|
||
* `DAGCircuit.get_gate_nodes()` - Use `DAGCircuit.gate_nodes()` instead. Note that the return type is a list of `DAGNode` objects for `gate_nodes()` instead of the list of tuples previously returned by `get_gate_nodes()`.
|
||
|
||
* `DAGCircuit.get_named_nodes()` - Use `DAGCircuit.named_nodes()` instead. Note that the return type is a list of `DAGNode` objects for `named_nodes()` instead of the list of node\_ids previously returned by `get_named_nodes()`.
|
||
|
||
* `DAGCircuit.get_2q_nodes()` - Use `DAGCircuit.twoQ_gates()` instead. Note that the return type is a list of `DAGNode` objects for `twoQ_gates()` instead of the list of data\_dicts previously returned by `get_2q_nodes()`.
|
||
|
||
* `DAGCircuit.get_3q_or_more_nodes()` - Use `DAGCircuit.threeQ_or_more_gates()` instead. Note that the return type is a list of `DAGNode` objects for `threeQ_or_more_gates()` instead of the list of tuples previously returned by `get_3q_or_more_nodes()`.
|
||
|
||
* The following `qiskit.dagcircuit.DAGCircuit` methods had deprecated support for accepting a `node_id` as a parameter. This has been removed and now only `DAGNode` objects are accepted as input:
|
||
|
||
* `successors()`
|
||
* `predecessors()`
|
||
* `ancestors()`
|
||
* `descendants()`
|
||
* `bfs_successors()`
|
||
* `quantum_successors()`
|
||
* `remove_op_node()`
|
||
* `remove_ancestors_of()`
|
||
* `remove_descendants_of()`
|
||
* `remove_nonancestors_of()`
|
||
* `remove_nondescendants_of()`
|
||
* `substitute_node_with_dag()`
|
||
|
||
* The `qiskit.dagcircuit.DAGCircuit` method `rename_register()` has been removed. This was unused by all the qiskit code. If you were relying on it externally you’ll have to re-implement is an external function.
|
||
|
||
* The `qiskit.dagcircuit.DAGCircuit` property `multi_graph` has been removed. Direct access to the underlying `networkx` `multi_graph` object isn’t supported anymore. The API provided by the `DAGCircuit` class should be used instead.
|
||
|
||
* The deprecated exception class `qiskit.qiskiterror.QiskitError` has been removed. Instead you should use `qiskit.exceptions.QiskitError`.
|
||
|
||
* The boolean kwargs, `ignore_requires` and `ignore_preserves` from the `qiskit.transpiler.PassManager` constructor have been removed. These are no longer valid options.
|
||
|
||
* The module `qiskit.tools.logging` has been removed. This module was not used by anything and added nothing over the interfaces that Python’s standard library `logging` module provides. If you want to set a custom formatter for logging use the standard library `logging` module instead.
|
||
|
||
* The `CompositeGate` class has been removed. Instead you should directly create a instruction object from a circuit and append that to your circuit. For example, you can run something like:
|
||
|
||
```python
|
||
custom_gate_circ = qiskit.QuantumCircuit(2)
|
||
custom_gate_circ.x(1)
|
||
custom_gate_circ.h(0)
|
||
custom_gate_circ.cx(0, 1)
|
||
custom_gate = custom_gate_circ.to_instruction()
|
||
```
|
||
|
||
* The previously deprecated kwargs, `seed` and `config` for `qiskit.compiler.assemble()` have been removed use `seed_simulator` and `run_config` respectively instead.
|
||
|
||
* The previously deprecated converters `qiskit.converters.qobj_to_circuits()` and `qiskit.converters.circuits_to_qobj()` have been removed. Use `qiskit.assembler.disassemble()` and `qiskit.compiler.assemble()` respectively instead.
|
||
|
||
* The previously deprecated kwarg `seed_mapper` for `qiskit.compiler.transpile()` has been removed. Instead you should use `seed_transpiler`
|
||
|
||
* The previously deprecated kwargs `seed`, `seed_mapper`, `config`, and `circuits` for the `qiskit.execute()` function have been removed. Use `seed_simulator`, `seed_transpiler`, `run_config`, and `experiments` arguments respectively instead.
|
||
|
||
* The previously deprecated `qiskit.tools.qcvv` module has been removed use qiskit-ignis instead.
|
||
|
||
* The previously deprecated functions `qiskit.transpiler.transpile()` and `qiskit.transpiler.transpile_dag()` have been removed. Instead you should use `qiskit.compiler.transpile`. If you were using `transpile_dag()` this can be replaced by running:
|
||
|
||
```python
|
||
circ = qiskit.converters.dag_to_circuit(dag)
|
||
out_circ = qiskit.compiler.transpile(circ)
|
||
qiskit.converters.circuit_to_dag(out_circ)
|
||
```
|
||
|
||
* The previously deprecated function `qiskit.compile()` has been removed instead you should use `qiskit.compiler.transpile()` and `qiskit.compiler.assemble()`.
|
||
|
||
* The jupyter cell magic `%%qiskit_progress_bar` from `qiskit.tools.jupyter` has been changed to a line magic. This was done to better reflect how the magic is used and how it works. If you were using the `%%qiskit_progress_bar` cell magic in an existing notebook, you will have to update this to be a line magic by changing it to be `%qiskit_progress_bar` instead. Everything else should behave identically.
|
||
|
||
* The deprecated function `qiskit.tools.qi.qi.random_unitary_matrix()` has been removed. You should use the `qiskit.quantum_info.random.random_unitary()` function instead.
|
||
|
||
* The deprecated function `qiskit.tools.qi.qi.random_density_matrix()` has been removed. You should use the `qiskit.quantum_info.random.random_density_matrix()` function instead.
|
||
|
||
* The deprecated function `qiskit.tools.qi.qi.purity()` has been removed. You should the `qiskit.quantum_info.purity()` function instead.
|
||
|
||
* The deprecated `QuantumCircuit._attach()` method has been removed. You should use `QuantumCircuit.append()` instead.
|
||
|
||
* The `qiskit.qasm.Qasm` method `get_filename()` has been removed. You can use the `return_filename()` method instead.
|
||
|
||
* The deprecated `qiskit.mapper` module has been removed. The list of functions and classes with their alternatives are:
|
||
|
||
* `qiskit.mapper.CouplingMap`: `qiskit.transpiler.CouplingMap` should be used instead.
|
||
* `qiskit.mapper.Layout`: `qiskit.transpiler.Layout` should be used instead
|
||
* `qiskit.mapper.compiling.euler_angles_1q()`: `qiskit.quantum_info.synthesis.euler_angles_1q()` should be used instead
|
||
* `qiskit.mapper.compiling.two_qubit_kak()`: `qiskit.quantum_info.synthesis.two_qubit_cnot_decompose()` should be used instead.
|
||
|
||
The deprecated exception classes `qiskit.mapper.exceptions.CouplingError` and `qiskit.mapper.exceptions.LayoutError` don’t have an alternative since they serve no purpose without a `qiskit.mapper` module.
|
||
|
||
* The `qiskit.pulse.samplers` module has been moved to `qiskit.pulse.pulse_lib.samplers`. You will need to update imports of `qiskit.pulse.samplers` to `qiskit.pulse.pulse_lib.samplers`.
|
||
|
||
* [seaborn](https://seaborn.pydata.org/) is now a dependency for the function `qiskit.visualization.plot_state_qsphere()`. It is needed to generate proper angular color maps for the visualization. The `qiskit-terra[visualization]` extras install target has been updated to install `seaborn>=0.9.0` If you are using visualizations and specifically the `plot_state_qsphere()` function you can use that to install `seaborn` or just manually run `pip install seaborn>=0.9.0`
|
||
|
||
* The previously deprecated functions `qiksit.visualization.plot_state` and `qiskit.visualization.iplot_state` have been removed. Instead you should use the specific function for each plot type. You can refer to the following tables to map the deprecated functions to their equivalent new ones:
|
||
|
||
| Qiskit Terra 0.6 | Qiskit Terra 0.7+ |
|
||
| ----------------------------------- | ----------------------------- |
|
||
| plot\_state(rho) | plot\_state\_city(rho) |
|
||
| plot\_state(rho, method=’city’) | plot\_state\_city(rho) |
|
||
| plot\_state(rho, method=’paulivec’) | plot\_state\_paulivec(rho) |
|
||
| plot\_state(rho, method=’qsphere’) | plot\_state\_qsphere(rho) |
|
||
| plot\_state(rho, method=’bloch’) | plot\_bloch\_multivector(rho) |
|
||
| plot\_state(rho, method=’hinton’) | plot\_state\_hinton(rho) |
|
||
|
||
* The `pylatexenc` and `pillow` dependencies for the `latex` and `latex_source` circuit drawer backends are no longer listed as requirements. If you are going to use the latex circuit drawers ensure you have both packages installed or use the setuptools extras to install it along with qiskit-terra:
|
||
|
||
```python
|
||
pip install qiskit-terra[visualization]
|
||
```
|
||
|
||
* The root of the `qiskit` namespace will now emit a warning on import if either `qiskit.IBMQ` or `qiskit.Aer` could not be setup. This will occur whenever anything in the `qiskit` namespace is imported. These warnings were added to make it clear for users up front if they’re running qiskit and the qiskit-aer and qiskit-ibmq-provider packages could not be found. It’s not always clear if the packages are missing or python packaging/pip installed an element incorrectly until you go to use them and get an empty `ImportError`. These warnings should make it clear up front if there these commonly used aliases are missing.
|
||
|
||
However, for users that choose not to use either qiskit-aer or qiskit-ibmq-provider this might cause additional noise. For these users these warnings are easily suppressable using Python’s standard library `warnings`. Users can suppress the warnings by putting these two lines before any imports from qiskit:
|
||
|
||
```python
|
||
import warnings
|
||
warnings.filterwarnings('ignore', category=RuntimeWarning,
|
||
module='qiskit')
|
||
```
|
||
|
||
This will suppress the warnings emitted by not having qiskit-aer or qiskit-ibmq-provider installed, but still preserve any other warnings emitted by qiskit or any other package.
|
||
|
||
<span id="release-notes-0-9-0-deprecation-notes" />
|
||
|
||
<span id="id554" />
|
||
|
||
#### Deprecation Notes
|
||
|
||
* The `U` and `CX` gates have been deprecated. If you’re using these gates in your code you should update them to use `u3` and `cx` instead. For example, if you’re using the circuit gate functions `circuit.u_base()` and `circuit.cx_base()` you should update these to be `circuit.u3()` and `circuit.cx()` respectively.
|
||
|
||
* The `u0` gate has been deprecated in favor of using multiple `iden` gates and it will be removed in the future. If you’re using the `u0` gate in your circuit you should update your calls to use `iden`. For example, f you were using `circuit.u0(2)` in your circuit before that should be updated to be:
|
||
|
||
```python
|
||
circuit.iden()
|
||
circuit.iden()
|
||
```
|
||
|
||
instead.
|
||
|
||
* The `qiskit.pulse.DeviceSpecification` class is deprecated now. Instead you should use `qiskit.pulse.PulseChannelSpec`.
|
||
|
||
* Accessing a `qiskit.circuit.Qubit`, `qiskit.circuit.Clbit`, or `qiskit.circuit.Bit` class by index is deprecated (for compatibility with the `(register, index)` tuples that these classes replaced). Instead you should use the `register` and `index` attributes.
|
||
|
||
* Passing in a bit to the `qiskit.QuantumCircuit` method `append` as a tuple `(register, index)` is deprecated. Instead bit objects should be used directly.
|
||
|
||
* Accessing the elements of a `qiskit.transpiler.Layout` object with a tuple `(register, index)` is deprecated. Instead a bit object should be used directly.
|
||
|
||
* The `qiskit.transpiler.Layout` constructor method `qiskit.transpiler.Layout.from_tuplelist()` is deprecated. Instead the constructor `qiskit.transpiler.Layout.from_qubit_list()` should be used.
|
||
|
||
* The module `qiskit.pulse.ops` has been deprecated. All the functions it provided:
|
||
|
||
* `union`
|
||
* `flatten`
|
||
* `shift`
|
||
* `insert`
|
||
* `append`
|
||
|
||
have equivalent methods available directly on the `qiskit.pulse.Schedule` and `qiskit.pulse.Instruction` classes. Those methods should be used instead.
|
||
|
||
* The `qiskit.qasm.Qasm` method `get_tokens()` is deprecated. Instead you should use the `generate_tokens()` method.
|
||
|
||
* The `qiskit.qasm.qasmparser.QasmParser` method `get_tokens()` is deprecated. Instead you should use the `read_tokens()` method.
|
||
|
||
* The `as_dict()` method for the Qobj class has been deprecated and will be removed in the future. You should replace calls to it with `to_dict()` instead.
|
||
|
||
<span id="release-notes-0-9-0-bug-fixes" />
|
||
|
||
<span id="id555" />
|
||
|
||
#### Bug Fixes
|
||
|
||
* The definition of the `CU3Gate` has been changed to be equivalent to the canonical definition of a controlled `U3Gate`.
|
||
|
||
* The handling of layout in the pass manager has been standardized. This fixes several reported issues with handling layout. The `initial_layout` kwarg parameter on `qiskit.compiler.transpile()` and `qiskit.execute()` will now lay out your qubits from the circuit onto the desired qubits on the device when transpiling circuits.
|
||
|
||
* Support for n-qubit unitaries was added to the BasicAer simulator and `unitary` (arbitrary unitary gates) was added to the set of basis gates for the simulators
|
||
|
||
* The `qiskit.visualization.plost_state_qsphere()` has been updated to fix several issues with it. Now output Q Sphere visualization will be correctly generated and the following aspects have been updated:
|
||
|
||
* All complementary basis states are antipodal
|
||
|
||
* Phase is indicated by color of line and marker on sphere’s surface
|
||
|
||
* ## Probability is indicated by translucency of line and volume of marker on
|
||
|
||
sphere’s surface
|
||
|
||
<span id="release-notes-0-9-0-other-notes" />
|
||
|
||
<span id="id556" />
|
||
|
||
#### Other Notes
|
||
|
||
* The default PassManager for `qiskit.compiler.transpile()` and `qiskit.execute()` has been changed to optimization level 1 pass manager defined at `qiskit.transpile.preset_passmanagers.level1_pass_manager`.
|
||
|
||
* All the circuit drawer backends now will express gate parameters in a circuit as common fractions of pi in the output visualization. If the value of a parameter can be expressed as a fraction of pi that will be used instead of the numeric equivalent.
|
||
|
||
* When using `qiskit.assembler.assemble_schedules()` if you do not provide the number of memory\_slots to use the number will be inferred based on the number of acquisitions in the input schedules.
|
||
|
||
* The deprecation warning on the `qiskit.dagcircuit.DAGCircuit` property `node_counter` has been removed. The behavior change being warned about was put into effect when the warning was added, so warning that it had changed served no purpose.
|
||
|
||
* Calls to `PassManager.run()` now will emit python logging messages at the INFO level for each pass execution. These messages will include the Pass name and the total execution time of the pass. Python’s standard logging was used because it allows Qiskit-Terra’s logging to integrate in a standard way with other applications and libraries. All logging for the transpiler occurs under the `qiskit.transpiler` namespace, as used by `logging.getLogger('qiskit.transpiler`). For example, to turn on DEBUG level logging for the transpiler you can run:
|
||
|
||
```python
|
||
import logging
|
||
|
||
logging.basicConfig()
|
||
logging.getLogger('qiskit.transpiler').setLevel(logging.DEBUG)
|
||
```
|
||
|
||
which will set the log level for the transpiler to DEBUG and configure those messages to be printed to stderr.
|
||
|
||
<span id="id557" />
|
||
|
||
### Aer 0.3
|
||
|
||
* There’s a new high-performance Density Matrix Simulator that can be used in conjunction with our noise models, to better simulate real world scenarios.
|
||
* We have added a Matrix Product State (MPS) simulator. MPS allows for efficient simulation of several classes of quantum circuits, even under presence of strong correlations and highly entangled states. For cases amenable to MPS, circuits with several hundred qubits and more can be exactly simulated, e.g., for the purpose of obtaining expectation values of observables.
|
||
* Snapshots can be performed in all of our simulators.
|
||
* Now we can measure sampling circuits with read-out errors too, not only ideal circuits.
|
||
* We have increased some circuit optimizations with noise presence.
|
||
* A better 2-qubit error approximations have been included.
|
||
* Included some tools for making certain noisy simulations easier to craft and faster to simulate.
|
||
* Increased performance with simulations that require less floating point numerical precision.
|
||
|
||
<span id="id558" />
|
||
|
||
### Ignis 0.2
|
||
|
||
<span id="id559" />
|
||
|
||
#### New Features
|
||
|
||
* [Logging Module](https://github.com/Qiskit/qiskit-iqx-tutorials/blob/stable/0.12.x/qiskit/advanced/ignis/9_ignis_logging.ipynb)
|
||
* [Purity RB](https://github.com/Qiskit/qiskit-iqx-tutorials/blob/stable/0.12.x/qiskit/advanced/ignis/5c_purity_rb.ipynb)
|
||
* [Interleaved RB](https://github.com/Qiskit/qiskit-iqx-tutorials/blob/stable/0.12.x/qiskit/advanced/ignis/5b_interleaved_rb.ipynb)
|
||
* [Repetition Code for Verification](https://github.com/Qiskit/qiskit-iqx-tutorials/blob/stable/0.12.x/qiskit/advanced/ignis/8_repetition_code.ipynb)
|
||
* Seed values can now be arbitrarily added to RB (not just in order)
|
||
* Support for adding multiple results to measurement mitigation
|
||
* RB Fitters now support providing guess values
|
||
|
||
<span id="id560" />
|
||
|
||
#### Bug Fixes
|
||
|
||
* Fixed a bug in RB fit error
|
||
* Fixed a bug in the characterization fitter when selecting a qubit index to fit
|
||
|
||
<span id="id561" />
|
||
|
||
#### Other Notes
|
||
|
||
* Measurement mitigation now operates in parallel when applied to multiple results
|
||
* Guess values for RB fitters are improved
|
||
|
||
<span id="id562" />
|
||
|
||
### Aqua 0.6
|
||
|
||
<span id="id563" />
|
||
|
||
#### Added
|
||
|
||
* Relative-Phase Toffoli gates `rccx` (with 2 controls) and `rcccx` (with 3 controls).
|
||
|
||
* Variational form `RYCRX`
|
||
|
||
* A new `'basic-no-ancilla'` mode to `mct`.
|
||
|
||
* Multi-controlled rotation gates `mcrx`, `mcry`, and `mcrz` as a general `u3` gate is not supported by graycode implementation
|
||
|
||
* Chemistry: ROHF open-shell support
|
||
|
||
* Supported for all drivers: Gaussian16, PyQuante, PySCF and PSI4
|
||
* HartreeFock initial state, UCCSD variational form and two qubit reduction for parity mapping now support different alpha and beta particle numbers for open shell support
|
||
|
||
* Chemistry: UHF open-shell support
|
||
|
||
* Supported for all drivers: Gaussian16, PyQuante, PySCF and PSI4
|
||
* QMolecule extended to include integrals, coefficients etc for separate beta
|
||
|
||
* Chemistry: QMolecule extended with integrals in atomic orbital basis to facilitate common access to these for experimentation
|
||
|
||
* Supported for all drivers: Gaussian16, PyQuante, PySCF and PSI4
|
||
|
||
* Chemistry: Additional PyQuante and PySCF driver configuration
|
||
|
||
* Convergence tolerance and max convergence iteration controls.
|
||
* For PySCF initial guess choice
|
||
|
||
* Chemistry: Processing output added to debug log from PyQuante and PySCF computations (Gaussian16 and PSI4 outputs were already added to debug log)
|
||
|
||
* Chemistry: Merged qiskit-chemistry into qiskit-aqua
|
||
|
||
* Add `MatrixOperator`, `WeightedPauliOperator` and `TPBGroupedPauliOperator` class.
|
||
|
||
* Add `evolution_instruction` function to get registerless instruction of time evolution.
|
||
|
||
* Add `op_converter` module to unify the place in charge of converting different types of operators.
|
||
|
||
* Add `Z2Symmetries` class to encapsulate the Z2 symmetries info and has helper methods for tapering an Operator.
|
||
|
||
* Amplitude Estimation: added maximum likelihood postprocessing and confidence interval computation.
|
||
|
||
* Maximum Likelihood Amplitude Estimation (MLAE): Implemented new algorithm for amplitude estimation based on maximum likelihood estimation, which reduces number of required qubits and circuit depth.
|
||
|
||
* Added (piecewise) linearly and polynomially controlled Pauli-rotation circuits.
|
||
|
||
* Add `q_equation_of_motion` to study excited state of a molecule, and add two algorithms to prepare the reference state.
|
||
|
||
<span id="id564" />
|
||
|
||
#### Changed
|
||
|
||
* Improve `mct`’s `'basic'` mode by using relative-phase Toffoli gates to build intermediate results.
|
||
* Adapt to Qiskit Terra’s newly introduced `Qubit` class.
|
||
* Prevent `QPE/IQPE` from modifying input `Operator` objects.
|
||
* The PyEDA dependency was removed; corresponding oracles’ underlying logic operations are now handled by SymPy.
|
||
* Refactor the `Operator` class, each representation has its own class `MatrixOperator`, `WeightedPauliOperator` and `TPBGroupedPauliOperator`.
|
||
* The `power` in `evolution_instruction` was applied on the theta on the CRZ gate directly, the new version repeats the circuits to implement power.
|
||
* CircuitCache is OFF by default, and it can be set via environment variable now `QISKIT_AQUA_CIRCUIT_CACHE`.
|
||
|
||
<span id="id565" />
|
||
|
||
#### Bug Fixes
|
||
|
||
* A bug where `TruthTableOracle` would build incorrect circuits for truth tables with only a single `1` value.
|
||
* A bug caused by `PyEDA`’s indeterminism.
|
||
* A bug with `QPE/IQPE`’s translation and stretch computation.
|
||
* Chemistry: Bravyi-Kitaev mapping fixed when num qubits was not a power of 2
|
||
* Setup `initial_layout` in `QuantumInstance` via a list.
|
||
|
||
<span id="id566" />
|
||
|
||
#### Removed
|
||
|
||
* General multi-controlled rotation gate `mcu3` is removed and replaced by multi-controlled rotation gates `mcrx`, `mcry`, and `mcrz`
|
||
|
||
<span id="id567" />
|
||
|
||
#### Deprecated
|
||
|
||
* The `Operator` class is deprecated, in favor of using `MatrixOperator`, `WeightedPauliOperator` and `TPBGroupedPauliOperator`.
|
||
|
||
<span id="id568" />
|
||
|
||
### IBM Q Provider 0.3
|
||
|
||
No change
|
||
|
||
<span id="qiskit-0-11-1" />
|