# 릴리스 노트¶

## 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.7.0, 0.7.1, 0.7.2 메타-패키지 릴리즈에 대해서는 버전_전략(versioning_strategy) 정책이 아직 공식적으로 정해지지 않았다.

## Notable Changes¶

### Qiskit 0.23.1¶

#### Terra 0.16.1¶

##### 버그 수정¶
• Fixed an issue where an error was thrown in execute for valid circuits built with delays.

• The QASM definition of 〈c4x〉 in qelib1.inc has been corrected to match the standard library definition for C4XGate.

• Fixes a bug in subtraction for quantum channels $$A - B$$ where $$B$$ was an Operator object. Negation was being applied to the matrix in the Operator representation which is not equivalent to negation in the quantum channel representation.

• Changes the way _evolve_instruction() access qubits to handle the case of an instruction with multiple registers.

#### Aer 0.7.1¶

• The minimum cmake version to build qiskit-aer has increased from 3.6 to 3.8. This change was necessary to enable fixing GPU version builds that support running on x86_64 CPUs lacking AVX2 instructions.

##### 버그 수정¶
• qiskit-aer with GPU support will now work on systems with x86_64 CPUs lacking AVX2 instructions. Previously, the GPU package would only run if the AVX2 instructions were available. Fixes #1023

• Fixes bug with AerProvider where options set on the returned backends using set_options() were stored in the provider and would persist for subsequent calls to get_backend() for the same named backend. Now every call to and backends() returns a new instance of the simulator backend that can be configured.

• Fixes bug in the error message returned when a circuit contains unsupported simulator instructions. Previously some supported instructions were also being listed in the error message along with the unsupported instructions.

• Fix bug where the 《sx》 gate SXGate was not listed as a supported gate in the C++ code, in StateOpSet of matrix_product_state.hp.

• Fix bug where "csx", "cu2", "cu3" were incorrectly listed as supported basis gates for the "density_matrix" method of the QasmSimulator.

• In MPS, apply_kraus was operating directly on the input bits in the parameter qubits, instead of on the internal qubits. In the MPS algorithm, the qubits are constantly moving around so all operations should be applied to the internal qubits.

• When invoking MPS::sample_measure, we need to first sort the qubits to the default ordering because this is the assumption in qasm_controller.This is done by invoking the method move_all_qubits_to_sorted_ordering. It was correct in sample_measure_using_apply_measure, but missing in sample_measure_using_probabilities.

#### Ignis 0.5.1¶

##### 버그 수정¶
• Fix the "auto" method of the TomographyFitter, StateTomographyFitter, and ProcessTomographyFitter to only use "cvx" if CVXPY is installed and a third-party SDP solver other than SCS is available. This is because the SCS solver has lower accuracy than other solver methods and often returns a density matrix or Choi-matrix that is not completely-positive and fails validation when used with the qiskit.quantum_info.state_fidelity() or qiskit.quantum_info.process_fidelity() functions.

#### 0.8.1¶

##### 새로운 기능¶
• A new algorithm has been added: the Born Openheimer Potential Energy surface for the calculation of potential energy surface along different degrees of freedom of the molecule. The algorithm is called BOPESSampler. It further provides functionalities of fitting the potential energy surface to an analytic function of predefined potentials.some details.

##### Critical Issues¶
• Be aware that initial_state parameter in QAOA has now different implementation as a result of a bug fix. The previous implementation wrongly mixed the user provided initial_state with Hadamard gates. The issue is fixed now. No attention needed if your code does not make use of the user provided initial_state parameter.

##### 버그 수정¶
• optimize_svm method of qp_solver would sometimes fail resulting in an error like this ValueError: cannot reshape array of size 1 into shape (200,1) This addresses the issue by adding an L2 norm parameter, lambda2, which defaults to 0.001 but can be changed via the QSVM algorithm, as needed, to facilitate convergence.

• A method one_letter_symbol has been removed from the VarType in the latest build of DOCplex making Aqua incompatible with this version. So instead of using this method an explicit type check of variable types has been introduced in the Aqua optimization module.

• :meth~qiskit.aqua.operators.state_fns.DictStateFn.sample() could only handle real amplitudes, but it is fixed to handle complex amplitudes. #1311 <https://github.com/Qiskit/qiskit-aqua/issues/1311> for more details.

• Trotter class did not use the reps argument in constructor. #1317 <https://github.com/Qiskit/qiskit-aqua/issues/1317> for more details.

• Raise an AquaError if :classqiskit.aqua.operators.converters.CircuitSampler samples an empty operator. #1321 <https://github.com/Qiskit/qiskit-aqua/issues/1321> for more details.

• to_opflow() returns a correct operator when coefficients are complex numbers. #1381 <https://github.com/Qiskit/qiskit-aqua/issues/1381> for more details.

• Let backend simulators validate NoiseModel support instead of restricting to Aer only in QuantumInstance.

• Correctly handle PassManager on QuantumInstance transpile method by calling its run method if it exists.

• A bug that mixes custom initial_state in QAOA with Hadamard gates has been fixed. This doesn’t change functionality of QAOA if no initial_state is provided by the user. Attention should be taken if your implementation uses QAOA with cusom initial_state parameter as the optimization results might differ.

• Previously, setting seed_simulator=0 in the QuantumInstance did not set any seed. This was only affecting the value 0. This has been fixed.

#### IBM Q Provider 0.11.0¶

##### 버그 수정¶
• Fixes the issue wherein a job could be left in the CREATING state if job submit fails half-way through.

• Fixes the infinite loop raised when passing an IBMQRandomService instance to a child process.

### Qiskit 0.23.0¶

#### Terra 0.16.0¶

##### 도입¶

The 0.16.0 release includes several new features and bug fixes. The major features in this release are the following:

• Introduction of scheduled circuits, where delays can be used to control the timing and alignment of operations in the circuit.

• Compilation of quantum circuits from classical functions, such as oracles.

• Ability to compile and optimize single qubit rotations over different Euler basis as well as the phase + square-root(X) basis (i.e. ['p', 'sx']), which will replace the older IBM Quantum basis of ['u1', 'u2', 'u3'].

• Tracking of global_phase() on the QuantumCircuit class has been extended through the transpiler, quantum_info, and assembler modules, as well as the BasicAer and Aer simulators. Unitary and state vector simulations will now return global phase-correct unitary matrices and state vectors.

Also of particular importance for this release is that Python 3.5 is no longer supported. If you are using Qiskit Terra with Python 3.5, the 0.15.2 release is that last version which will work.

##### 새로운 기능¶
• Global R gates have been added to qiskit.circuit.library. This includes the global R gate (GR), global Rx (GRX) and global Ry (GRY) gates which are derived from the GR gate, and global Rz ( GRZ) that is defined in a similar way to the GR gates. The global R gates are defined on a number of qubits simultaneously, and act as a direct sum of R gates on each qubit.

For example:

from qiskit import QuantumCircuit, QuantumRegister
import numpy as np

num_qubits = 3
qr = QuantumRegister(num_qubits)
qc = QuantumCircuit(qr)

qc.compose(GR(num_qubits, theta=np.pi/3, phi=2*np.pi/3), inplace=True)


will create a QuantumCircuit on a QuantumRegister of 3 qubits and perform a RGate of an angle $$\theta = \frac{\pi}{3}$$ about an axis in the xy-plane of the Bloch spheres that makes an angle of $$\phi = \frac{2\pi}{3}$$ with the x-axis on each qubit.

• A new color scheme, iqx, has been added to the mpl backend for the circuit drawer qiskit.visualization.circuit_drawer() and qiskit.circuit.QuantumCircuit.draw(). This uses the same color scheme as the Circuit Composer on the IBM Quantum Experience website. There are now 3 available color schemes - default, iqx, and bw.

There are two ways to select a color scheme. The first is to use a user config file, by default in the ~/.qiskit directory, in the file settings.conf under the [Default] heading, a user can enter circuit_mpl_style = iqx to select the iqx color scheme.

The second way is to add {'name': 'iqx'} to the style kwarg to the QuantumCircuit.draw method or to the circuit_drawer function. The second way will override the setting in the settings.conf file. For example:

from qiskit.circuit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()
circuit.draw('mpl', style={'name': 'iqx'})

• In the style kwarg for the the circuit drawer qiskit.visualization.circuit_drawer() and qiskit.circuit.QuantumCircuit.draw() the displaycolor field with the mpl backend now allows for entering both the gate color and the text color for each gate type in the form (gate_color, text_color). This allows the use of light and dark gate colors with contrasting text colors. Users can still set only the gate color, in which case the gatetextcolor field will be used. Gate colors can be set in the style dict for any number of gate types, from one to the entire displaycolor dict. For example:

from qiskit.circuit import QuantumCircuit

circuit = QuantumCircuit(1)
circuit.h(0)

style_dict = {'displaycolor': {'h': ('#FA74A6', '#000000')}}
circuit.draw('mpl', style=style_dict)


or

style_dict = {'displaycolor': {'h': '#FA74A6'}}
circuit.draw('mpl', style=style_dict)

• Two alignment contexts are added to the pulse builder (qiskit.pulse.builder) to facilitate writing a repeated pulse sequence with delays.

• A rep_delay parameter has been added to the QasmQobj class under the run configuration, QasmQobjConfig. This parameter is used to denote the time between program executions. It must be chosen from the backend range given by the BackendConfiguration method rep_delay_range(). If a value is not provided a backend default, qiskit.providers.models.BackendConfiguration.default_rep_delay, will be used. rep_delay will only work on backends which allow for dynamic repetition time. This is can be checked with the BackendConfiguration property dynamic_reprate_enabled.

• The qobj_schema.json JSON Schema file in qiskit.schemas has been updated to include the rep_delay as an optional configuration property for QASM Qobjs.

• The backend_configuration_schema.json JSON Schema file in qiskit.schemas has been updated to include dynamic_reprate_enabled, rep_delay_range and default_rep_delay as optional properties for a QASM backend configuration payload.

• A new optimization pass, qiskit.transpiler.passes.TemplateOptimization has been added to the transpiler. This pass applies a template matching algorithm described in arXiv:1909.05270 that replaces all compatible maximal matches in the circuit.

To implement this new transpiler pass a new module, template_circuits, was added to the circuit library (qiskit.circuit.library). This new module contains all the Toffoli circuit templates used in the TemplateOptimization.

This new pass is not currently included in the preset pass managers (qiskit.transpiler.preset_passmanagers), to use it you will need to create a custom PassManager.

• A new version of the providers interface has been added. This new interface, which can be found in qiskit.providers, provides a new versioning mechanism that will enable changes to the interface to happen in a compatible manner over time. The new interface should be simple to migrate existing providers, as it is mostly identical except for the explicit versioning.

Besides having explicitly versioned abstract classes the key changes for the new interface are that the BackendV1 method run() can now take a QuantumCircuit or Schedule object as inputs instead of Qobj objects. To go along with that options are now part of a backend class so that users can configure run time options when running with a circuit. The final change is that qiskit.providers.JobV1 can now be synchronous or asynchronous, the exact configuration and method for configuring this is up to the provider, but there are interface hook points to make it explicit which execution model a job is running under in the JobV1 abstract class.

• A new kwarg, inplace, has been added to the function qiskit.result.marginal_counts(). This kwarg is used to control whether the contents are marginalized in place or a new copy is returned, for Result object input. This parameter does not have any effect for an input dict or Counts object.

• An initial version of a classical function compiler, qiskit.circuit.classicalfunction, has been added. This enables compiling typed python functions (operating only on bits of type Int1 at the moment) into QuantumCircuit objects. For example:

from qiskit.circuit import classical_function, Int1

@classical_function
def grover_oracle(a: Int1, b: Int1, c: Int1, d: Int1) -> Int1:
x = not a and b
y = d and not c
z = not x or y
return z

quantum_circuit = grover_oracle.synth()
quantum_circuit.draw()


q_0: ──o────■────■────o────────────
│    │    │    │
q_1: ──o────o────┼────┼────■────o──
│    │    │    │    │    │
q_2: ──o────■────o────┼────■────┼──
│    │    │    │    │    │
q_3: ──■────┼────■────┼────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_4: ┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘└───┘└───┘

The parameter registerless=False in the qiskit.circuit.classicalfunction.ClassicalFunction method synth() creates a circuit with registers refering to the parameter names. For example:

quantum_circuit = grover_oracle.synth(registerless=False)
quantum_circuit.draw()


d_0: ──o────■────■────o────────────
│    │    │    │
c_0: ──o────o────┼────┼────■────o──
│    │    │    │    │    │
b_0: ──o────■────o────┼────■────┼──
│    │    │    │    │    │
a_0: ──■────┼────■────┼────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
return_0: ┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘└───┘└───┘

A decorated classical function can be used the same way as any other quantum gate when appending it to a circuit.

circuit = QuantumCircuit(5)
circuit.append(grover_oracle, range(5))
circuit.draw()

     ┌────────────────┐
q_0: ┤0               ├
│                │
q_1: ┤1               ├
│                │
q_2: ┤2 GROVER_ORACLE ├
│                │
q_3: ┤3               ├
│                │
q_4: ┤4               ├
└────────────────┘

The GROVER_ORACLE gate is synthesized when its decomposition is required.

circuit.decompose().draw()


q_0: ──o────■────■────o────────────
│    │    │    │
q_1: ──o────o────┼────┼────■────o──
│    │    │    │    │    │
q_2: ──o────■────o────┼────■────┼──
│    │    │    │    │    │
q_3: ──■────┼────■────┼────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_4: ┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘└───┘└───┘

The feature requires tweedledum, a library for synthesizing quantum circuits, that can be installed via pip with pip install tweedledum.

• A new class qiskit.circuit.Delay for representing a delay instruction in a circuit has been added. A new method delay() is now available for easily appending delays to circuits. This makes it possible to describe timing-sensitive experiments (e.g. T1/T2 experiment) in the circuit level.

from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.delay(500, 0, unit='ns')
qc.measure(0, 0)

qc.draw()

     ┌────────────────┐┌─┐
q_0: ┤ DELAY(500[ns]) ├┤M├
└────────────────┘└╥┘
c: 1/═══════════════════╩═
0 
• A new argument scheduling_method for qiskit.compiler.transpile() has been added. It is required when transpiling circuits with delays. If scheduling_method is specified, the transpiler returns a scheduled circuit such that all idle times in it are padded with delays (i.e. start time of each instruction is uniquely determined). This makes it possible to see how scheduled instructions (gates) look in the circuit level.

from qiskit import QuantumCircuit, transpile
from qiskit.test.mock.backends import FakeAthens

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

scheduled_circuit = transpile(qc, backend=FakeAthens(), scheduling_method="alap")
print("Duration in dt:", scheduled_circuit.duration)
scheduled_circuit.draw(idle_wires=False)

Duration in dt: 2016

                   ┌─────────┐
q_0 -> 0 ────┤ U2(0,π) ├──────■──
┌──┴─────────┴───┐┌─┴─┐
q_1 -> 1 ─┤ DELAY(160[dt]) ├┤ X ├
┌┴────────────────┤└───┘
ancilla_0 -> 2 ┤ DELAY(2016[dt]) ├─────
├─────────────────┤
ancilla_1 -> 3 ┤ DELAY(2016[dt]) ├─────
├─────────────────┤
ancilla_2 -> 4 ┤ DELAY(2016[dt]) ├─────
└─────────────────┘     

See also timeline_drawer() for the best visualization of scheduled circuits.

• A new fuction qiskit.compiler.sequence() has been also added so that we can convert a scheduled circuit into a Schedule to make it executable on a pulse-enabled backend.

from qiskit.compiler import sequence

sched = sequence(scheduled_circuit, pulse_enabled_backend)

• The schedule() has been updated so that it can schedule circuits with delays. Now there are two paths to schedule a circuit with delay:

qc = QuantumCircuit(1, 1)
qc.h(0)
qc.delay(500, 0, unit='ns')
qc.h(0)
qc.measure(0, 0)

sched_path1 = schedule(qc.decompose(), backend)
sched_path2 = sequence(transpile(qc, backend, scheduling_method='alap'), backend)


Refer to the release notes and documentation for transpile() and sequence() for the details on the other path.

• Added the GroverOperator to the circuit library (qiskit.circuit.library) to construct the Grover operator used in Grover’s search algorithm and Quantum Amplitude Amplification/Estimation. Provided with an oracle in form of a circuit, GroverOperator creates the textbook Grover operator. To generalize this for amplitude amplification and use a generic operator instead of Hadamard gates as state preparation, the state_in argument can be used.

• The InstructionScheduleMap methods get() and pop() methods now take ParameterExpression instances in addition to numerical values for schedule generator parameters. If the generator is a function, expressions may be bound before or within the function call. If the generator is a ParametrizedSchedule, expressions must be bound before the schedule itself is bound/called.

• A new class LinearAmplitudeFunction was added to the circuit library (qiskit.circuit.library) for mapping (piecewise) linear functions on qubit amplitudes,

$F|x\rangle |0\rangle = \sqrt{1 - f(x)}|x\rangle |0\rangle + \sqrt{f(x)}|x\rangle |1\rangle$

The mapping is based on a controlled Pauli Y-rotations and a Taylor approximation, as described in https://arxiv.org/abs/1806.06893. This circuit can be used to compute expectation values of linear functions using the quantum amplitude estimation algorithm.

• The new jupyter magic monospaced_output has been added to the qiskit.tools.jupyter module. This magic sets the Jupyter notebook output font to 《Courier New》, when possible. When used this fonts returns text circuit drawings that are better aligned.

import qiskit.tools.jupyter
%monospaced_output

• A new transpiler pass, Optimize1qGatesDecomposition, has been added. This transpiler pass is an alternative to the existing Optimize1qGates that uses the OneQubitEulerDecomposer class to decompose and simplify a chain of single qubit gates. This method is compatible with any basis set, while Optimize1qGates only works for u1, u2, and u3. The default pass managers for optimization_level 1, 2, and 3 have been updated to use this new pass if the basis set doesn’t include u1, u2, or u3.

• The OneQubitEulerDecomposer now supports two new basis, 'PSX' and 'U'. These can be specified with the basis kwarg on the constructor. This will decompose the matrix into a circuit using PGate and SXGate for 'PSX', and UGate for 'U'.

• A new method remove() has been added to the qiskit.transpiler.PassManager class. This method enables removing a pass from a PassManager instance. It works on indexes, similar to replace(). For example, to remove the RemoveResetInZeroState pass from the pass manager used at optimization level 1:

from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
from qiskit.transpiler.passmanager_config import PassManagerConfig

pm = level_1_pass_manager(PassManagerConfig())
pm.draw()

[0] FlowLinear: UnrollCustomDefinitions, BasisTranslator
[1] FlowLinear: RemoveResetInZeroState
[2] DoWhile: Depth, FixedPoint, Optimize1qGates, CXCancellation


The stage [1] with RemoveResetInZeroState can be removed like this:

pass_manager.remove(1)
pass_manager.draw()

[0] FlowLinear: UnrollCustomDefinitions, BasisTranslator
[1] DoWhile: Depth, FixedPoint, Optimize1qGates, CXCancellation

• Several classes to load probability distributions into qubit amplitudes; UniformDistribution, NormalDistribution, and LogNormalDistribution were added to the circuit library (qiskit.circuit.library). The normal and log-normal distribution support both univariate and multivariate distributions. These circuits are central to applications in finance where quantum amplitude estimation is used.

• Support for pulse gates has been added to the QuantumCircuit class. This enables a QuantumCircuit to override (for basis gates) or specify (for standard and custom gates) a definition of a Gate operation in terms of time-ordered signals across hardware channels. In other words, it enables the option to provide pulse-level custom gate calibrations.

The circuits are built exactly as before. For example:

from qiskit import pulse
from qiskit.circuit import QuantumCircuit, Gate

class RxGate(Gate):
def __init__(self, theta):
super().__init__('rxtheta', 1, [theta])

circ = QuantumCircuit(1)
circ.h(0)
circ.append(RxGate(3.14), [0])


Then, the calibration for the gate can be registered using the QuantumCircuit method add_calibration() which takes a Schedule definition as well as the qubits and parameters that it is defined for:

# Define the gate implementation as a schedule
with pulse.build() as custom_h_schedule:
pulse.play(pulse.library.Drag(...), pulse.DriveChannel(0))

with pulse.build() as q1_x180:
pulse.play(pulse.library.Gaussian(...), pulse.DriveChannel(1))

# Register the schedule to the gate
circ.add_calibration('h', [0], custom_h_schedule)  # or gate.name string to register
circ.add_calibration(RxGate(3.14), [0], q1_x180)   # Can accept gate


Previously, this functionality could only be used through complete Pulse Schedules. Additionally, circuits can now be submitted to backends with your custom definitions (dependent on backend support).

Circuits with pulse gates can still be lowered to a Schedule by using the schedule() function.

The calibrated gate can also be transpiled using the regular transpilation process:

transpiled_circuit = transpile(circ, backend)


The transpiled circuit will leave the calibrated gates on the same qubit as the original circuit and will not unroll them to the basis gates.

• Support for disassembly of PulseQobj objects has been added to the qiskit.assembler.disassemble() function. For example:

from qiskit import pulse
from qiskit.assembler.disassemble import disassemble
from qiskit.compiler.assemble import assemble
from qiskit.test.mock import FakeOpenPulse2Q

backend = FakeOpenPulse2Q()

d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
with pulse.build(backend) as sched:
with pulse.align_right():
pulse.play(pulse.library.Constant(10, 1.0), d0)
pulse.shift_phase(3.11, d0)
pulse.measure_all()

qobj = assemble(sched, backend=backend, shots=512)

• A new kwarg, coord_type has been added to qiskit.visualization.plot_bloch_vector(). This kwarg enables changing the coordinate system used for the input parameter that describes the positioning of the vector on the Bloch sphere in the generated visualization. There are 2 supported values for this new kwarg, 'cartesian' (the default value) and 'spherical'. If the coord_type kwarg is set to 'spherical' the list of parameters taken in are of the form [r, theta,  phi] where r is the radius, theta is the inclination from +z direction, and phi is the azimuth from +x direction. For example:

from numpy import pi

from qiskit.visualization import plot_bloch_vector

x = 0
y = 0
z = 1
r = 1
theta = pi
phi = 0

# Cartesian coordinates, where (x,y,z) are cartesian coordinates
# for bloch vector
plot_bloch_vector([x,y,z])

plot_bloch_vector([x,y,z], coord_type="cartesian")  # Same as line above

# Spherical coordinates, where (r,theta,phi) are spherical coordinates
# for bloch vector
plot_bloch_vector([r, theta, phi], coord_type="spherical")

• Pulse Schedule objects now support using ParameterExpression objects for parameters.

For example:

from qiskit.circuit import Parameter
from qiskit import pulse

alpha = Parameter('⍺')
phi = Parameter('ϕ')
qubit = Parameter('q')
amp = Parameter('amp')

schedule = pulse.Schedule()
schedule += SetFrequency(alpha, DriveChannel(qubit))
schedule += ShiftPhase(phi, DriveChannel(qubit))
schedule += Play(Gaussian(duration=128, sigma=4, amp=amp),
DriveChannel(qubit))
schedule += ShiftPhase(-phi, DriveChannel(qubit))


Parameter assignment is done via the assign_parameters() method:

schedule.assign_parameters({alpha: 4.5e9, phi: 1.57,
qubit: 0, amp: 0.2})


Expressions and partial assignment also work, such as:

beta = Parameter('b')
schedule += SetFrequency(alpha + beta, DriveChannel(0))
schedule.assign_parameters({alpha: 4.5e9})
schedule.assign_parameters({beta: phi / 6.28})

• A new visualization function timeline_drawer() was added to the qiskit.visualization module.

For example:

from qiskit.visualization import timeline_drawer
from qiskit import QuantumCircuit, transpile
from qiskit.test.mock import FakeAthens

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
timeline_drawer(transpile(qc, FakeAthens(), scheduling_method='alap'))

• Type checking for the params kwarg of the constructor for the Gate class and its subclasses has been changed. Previously all Gate parameters had to be in a set of allowed types defined in the Instruction class. Now a new method, validate_parameter() is used to determine if a parameter type is valid or not. The definition of this method in a subclass will take priority over its parent. For example, UnitaryGate accepts a parameter of the type numpy.ndarray and defines a custom validate_parameter() method that returns the parameter if it’s an numpy.ndarray. This takes priority over the function defined in its parent class Gate. If UnitaryGate were to be used as parent for a new class, this validate_parameter method would be used unless the new child class defines its own method.

• The previously deprecated methods, arguments, and properties named n_qubits and numberofqubits have been removed. These were deprecated in the 0.13.0 release. The full set of changes are:

클래스

Old

New

QuantumCircuit

n_qubits

num_qubits

Pauli

numberofqubits

num_qubits

Function

Old Argument

New Argument

qiskit.circuit.random.random_circuit()

n_qubits

num_qubits

qiskit.circuit.library.MSGate

n_qubits

num_qubits

• Inserting a parameterized Gate instance into a QuantumCircuit now creates a copy of that gate which is used in the circuit. If changes are made to the instance inserted into the circuit it will no longer be reflected in the gate in the circuit. This change was made to fix an issue when inserting a single parameterized Gate object into multiple circuits.

• The function qiskit.result.marginal_counts() now, by default, does not modify the qiskit.result.Result instance parameter. Previously, the Result object was always modified in place. A new kwarg inplace has been added marginal_counts() which enables using the previous behavior when inplace=True is set.

• The U3Gate definition has been changed to be in terms of the UGate class. The UGate class has no definition. It is therefore not possible to unroll every circuit in terms of U3 and CX anymore. Instead, U and CX can be used for every circuit.

• The deprecated support for running Qiskit Terra with Python 3.5 has been removed. To use Qiskit Terra from this release onward you will now need to use at least Python 3.6. If you are using Python 3.5 the last version which will work is Qiskit Terra 0.15.2.

• In the PulseBackendConfiguration in the hamiltonian attributes the vars field is now returned in a unit of Hz instead of the previously used GHz. This change was made to be consistent with the units used with the other attributes in the class.

• The previously deprecated support for passing in a dictionary as the first positional argument to DAGNode constructor has been removed. Using a dictonary for the first positional argument was deprecated in the 0.13.0 release. To create a DAGNode object now you should directly pass the attributes as kwargs on the constructor.

• The keyword arguments for the circuit gate methods (for example: qiskit.circuit.QuantumCircuit.cx) q, ctl*, and tgt*, which were deprecated in the 0.12.0 release, have been removed. Instead, only qubit, control_qubit* and target_qubit* can be used as named arguments for these methods.

• The previously deprecated module qiskit.extensions.standard has been removed. This module has been deprecated since the 0.14.0 release. The qiskit.circuit.library can be used instead. Additionally, all the gate classes previously in qiskit.extensions.standard are still importable from qiskit.extensions.

• The previously deprecated gates in the module qiskit.extensions.quantum_initializer: DiagGate, UCG, UCPauliRotGate, UCRot, UCRXGate, UCX, UCRYGate, UCY, UCRZGate, UCZ have been removed. These were all deprecated in the 0.14.0 release and have alternatives available in the circuit library (qiskit.circuit.library).

• The previously deprecated qiskit.circuit.QuantumCircuit gate method iden() has been removed. This was deprecated in the 0.13.0 release and i() or id() can be used instead.

#### Aer 0.7.0¶

##### 도입¶

This 0.7.0 release includes numerous performance improvements and significant enhancements to the simulator interface, and drops support for Python 3.5. The main interface changes are configurable simulator backends, and constructing preconfigured simulators from IBMQ backends. Noise model an basis gate support has also been extended for most of the Qiskit circuit library standard gates, including new support for 1 and 2-qubit rotation gates. Performance improvements include adding SIMD support to the density matrix and unitary simulation methods, reducing the used memory and improving the performance of circuits using statevector and density matrix snapshots, and adding support for Kraus instructions to the gate fusion circuit optimization for greatly improving the performance of noisy statevector simulations.

##### 새로운 기능¶
• AER now uses Lapack to perform some matrix related computations. It uses the Lapack library bundled with OpenBlas (already available in Linux and Macos typical OpenBlas dsitributions; Windows version distributed with AER) or with the accelerate framework in MacOS.

• The deprecated support for running qiskit-aer with Python 3.5 has been removed. To use qiskit-aer >=0.7.0 you will now need at least Python 3.6. If you are using Python 3.5 the last version which will work is qiskit-aer 0.6.x.

• Updates gate fusion default thresholds so that gate fusion will be applied to circuits with of more than 14 qubits for statevector simulations on the StatevectorSimulator and QasmSimulator.

For the "density_matrix" method of the QasmSimulator and for the UnitarySimulator gate fusion will be applied to circuits with more than 7 qubits.

Custom qubit threshold values can be set using the fusion_threshold backend option ie backend.set_options(fusion_threshold=10)

• Changes fusion_threshold backend option to apply fusion when the number of qubits is above the threshold, not equal or above the threshold, to match the behavior of the OpenMP qubit threshold parameter.

##### Deprecation Notes¶
• qiskit.providers.aer.noise.NoiseModel.set_x90_single_qubit_gates() has been deprecated as unrolling to custom basis gates has been added to the qiskit transpiler. The correct way to use an X90 based noise model is to define noise on the Sqrt(X) "sx" or "rx" gate and one of the single-qubit phase gates "u1", "rx", or "p" in the noise model.

• The variance kwarg of Snapshot instructions has been deprecated. This function computed the sample variance in the snapshot due to noise model sampling, not the variance due to measurement statistics so was often being used incorrectly. If noise modeling variance is required single shot snapshots should be used so variance can be computed manually in post-processing.

##### 버그 수정¶
• Fixes bug in the StatevectorSimulator that caused it to always run as CPU with double-precision without SIMD/AVX2 support even on systems with AVX2, or when single-precision or the GPU method was specified in the backend options.

• Fixes some for-loops in C++ code that were iterating over copies rather than references of container elements.

• Fixes a bug where snapshot data was always copied from C++ to Python rather than moved where possible. This will halve memory usage and improve simulation time when using large statevector or density matrix snapshots.

• Fix State::snapshot_pauli_expval to return correct Y expectation value in stabilizer simulator. Refer to #895 <https://github.com/Qiskit/qiskit-aer/issues/895> for more details.

• The controller_execute wrappers have been adjusted to be functors (objects) rather than free functions. Among other things, this allows them to be used in multiprocessing.pool.map calls.

• Add missing available memory checks for the StatevectorSimulator and UnitarySimulator. This throws an exception if the memory required to simulate the number of qubits in a circuit exceeds the available memory of the system.

#### Ignis 0.5.0¶

##### 도입¶

This release includes a new module for expectation value measurement error mitigation, improved plotting functionality for quantum volume experiments, several bug fixes, and drops support for Python 3.5.

##### 새로운 기능¶
• The qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() function allows an optional input of gate objects as interleaved_elem. In addition, the CNOT-Dihedral class qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral has a new method to_instruction, and the existing from_circuit method has an optional input of an Instruction (in addition to QuantumCircuit).

• The qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral now contains the following new features. Initialization from various types of objects: CNOTDihedral, ScalarOp, QuantumCircuit, Instruction and Pauli. Converting to a matrix using to_matrix and to an operator using to_operator. Tensor product methods tensor and expand. Calculation of the adjoint, conjugate and transpose using conjugate, adjoint and transpose methods. Verify that an element is CNOTDihedral using is_cnotdihedral method. Decomposition method to_circuit of a CNOTDihedral element into a circuit was extended to allow any number of qubits, based on the function decompose_cnotdihedral_general.

• Adds expectation value measurement error mitigation to the mitigation module. This supports using complete N-qubit assignment matrix, single-qubit tensored assignment matrix, or continuous time Markov process (CTMP) [1] measurement error mitigation when computing expectation values of diagonal operators from counts dictionaries. Expectation values are computed using the using the qiskit.ignis.mitigation.expectation_value() function.

Calibration circuits for calibrating a measurement error mitigator are generated using the qiskit.ignis.mitigation.expval_meas_mitigator_circuits() function, and the result fitted using the qiskit.ignis.mitigation.ExpvalMeasMitigatorFitter class. The fitter returns a mitigator object can the be supplied as an argument to the expectation_value() function to apply mitigation.

[1] S Bravyi, S Sheldon, A Kandala, DC Mckay, JM Gambetta,

Mitigating measurement errors in multi-qubit experiments, arXiv:2006.14044 [quant-ph].

Example:

The following example shows calibrating a 5-qubit expectation value measurement error mitigator using the 'tensored' method.

from qiskit import execute
from qiskit.test.mock import FakeVigo
import qiskit.ignis.mitigation as mit

backend = FakeVigo()
num_qubits = backend.configuration().num_qubits

# Generate calibration circuits
num_qubits, method='tensored')
result = execute(circuits, backend, shots=8192).result()

# Fit mitigator

# Plot fitted N-qubit assignment matrix
mitigator.plot_assignment_matrix()

<matplotlib.axes._subplots.AxesSubplot at 0x7f5cb030d970>


The following shows how to use the above mitigator to apply measurement error mitigation to expectation value computations

from qiskit import QuantumCircuit

# Test Circuit with expectation value -1.
qc = QuantumCircuit(num_qubits)
qc.x(range(num_qubits))
qc.measure_all()

# Execute
shots = 8192
seed_simulator = 1999
result = execute(qc, backend, shots=8192, seed_simulator=1999).result()
counts = result.get_counts(0)

# Expectation value of Z^N without mitigation
expval_nomit, error_nomit = mit.expectation_value(counts)
print('Expval (no mitigation): {:.2f} \u00B1 {:.2f}'.format(
expval_nomit, error_nomit))

# Expectation value of Z^N with mitigation
expval_mit, error_mit = mit.expectation_value(counts,
meas_mitigator=mitigator)
print('Expval (with mitigation): {:.2f} \u00B1 {:.2f}'.format(
expval_mit, error_mit))

Expval (no mitigation): -0.81 ± 0.01
Expval (with mitigation): -0.99 ± 0.01

• Adds Numba as an optional dependency. Numba is used to significantly increase the performance of the qiskit.ignis.mitigation.CTMPExpvalMeasMitigator class used for expectation value measurement error mitigation with the CTMP method.

• Add two methods to qiskit.ignis.verification.quantum_volume.QVFitter.

• qiskit.ignis.verification.quantum_volume.QVFitter.calc_z_value() to calculate z value in standard normal distribution using mean and standard deviation sigma. If sigma = 0, it raises a warning and assigns a small value (1e-10) for sigma so that the code still runs.

• qiskit.ignis.verification.quantum_volume.QVFitter.calc_confidence_level() to calculate confidence level using z value.

• Store confidence level even when hmean < 2/3 in qiskit.ignis.verification.quantum_volume.QVFitter.qv_success().

• Add explanations for how to calculate statistics based on binomial distribution in qiskit.ignis.verification.quantum_volume.QVFitter.calc_statistics().

• The qiskit.ignis.verification.QVFitter method plot_qv_data() has been updated to return a matplotlib.Figure object. Previously, it would not return anything. By returning a figure this makes it easier to integrate the visualizations into a larger matplotlib workflow.

• The error bars in the figure produced by the qiskit.ignis.verification.QVFitter method qiskit.ignis.verification.QVFitter.plot_qv_data() has been updated to represent two-sigma confidence intervals. Previously, the error bars represent one-sigma confidence intervals. The success criteria of Quantum Volume benchmarking requires heavy output probability > 2/3 with one-sided two-sigma confidence (~97.7%). Changing error bars to represent two-sigma confidence intervals allows easily identification of success in the figure.

• A new kwarg, figsize has been added to the qiskit.ignis.verification.QVFitter method qiskit.ignis.verification.QVFitter.plot_qv_data(). This kwarg takes in a tuple of the form (x, y) where x and y are the dimension in inches to make the generated plot.

• The qiskit.ignis.verification.quantum_volume.QVFitter.plot_hop_accumulative() method has been added to plot heavy output probability (HOP) vs number of trials similar to Figure 2a of Quantum Volume 64 paper (arXiv:2008.08571). HOP of individual trials are plotted as scatters and cummulative HOP are plotted in red line. Two-sigma confidence intervals are plotted as shaded area and 2/3 success threshold is plotted as dashed line.

• The qiskit.ignis.verification.quantum_volume.QVFitter.plot_qv_trial() method has been added to plot individual trials, leveraging on the qiskit.visualization.plot_histogram() method from Qiskit Terra. Bitstring counts are plotted as overlapping histograms for ideal (hollow) and experimental (filled) values. Experimental heavy output probability are shown on the legend. Median probability is plotted as red dashed line.

• The deprecated support for running qiskit-ignis with Python 3.5 has been removed. To use qiskit-ignis >=0.5.0 you will now need at least Python 3.6. If you are using Python 3.5 the last version which will work is qiskit-ignis 0.4.x.

##### 버그 수정¶
• Fixing a bug in the class qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral for elements with more than 5 quits.

• Fix the confidence level threshold for qiskit.ignis.verification.quantum_volume.QVFitter.qv_success() to 0.977 corresponding to z = 2 as defined by the QV paper Algorithm 1.

• Fix a bug at qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() which caused all the subsystems with the same size in the given rb_pattern to have the same gates when a 〈rand_seed〉 parameter was given to the function.

#### Aqua 0.8.0¶

##### 도입¶

This release introduces an interface for running the available methods for Bosonic problems. In particular we introduced a full interface for running vibronic structure calculations.

This release introduces an interface for excited states calculations. It is now easier for the user to create a general excited states calculation. This calculation is based on a Driver which provides the relevant information about the molecule, a Transformation which provides the information about the mapping of the problem into a qubit Hamiltonian, and finally a Solver. The Solver is the specific way which the excited states calculation is done (the algorithm). This structure follows the one of the ground state calculations. The results are modified to take lists of expectation values instead of a single one. The QEOM and NumpyEigensolver are adapted to the new structure. A factory is introduced to run a numpy eigensolver with a specific filter (to target states of specific symmetries).

VQE expectation computation with Aer qasm_simulator now defaults to a computation that has the expected shot noise behavior.

##### 새로운 기능¶
• Introduced an option warm_start that should be used when tuning other options does not help. When this option is enabled, a relaxed problem (all variables are continuous) is solved first and the solution is used to initialize the state of the optimizer before it starts the iterative process in the solve method.

• The amplitude estimation algorithms now use QuantumCircuit objects as inputs to specify the A- and Q operators. This change goes along with the introduction of the GroverOperator in the circuit library, which allows an intuitive and fast construction of different Q operators. For example, a Bernoulli-experiment can now be constructed as

import numpy as np
from qiskit import QuantumCircuit
from qiskit.aqua.algorithms import AmplitudeEstimation

probability = 0.5
angle = 2 * np.sqrt(np.arcsin(probability))
a_operator = QuantumCircuit(1)
a_operator.ry(angle, 0)

# construct directly
q_operator = QuantumCircuit(1)
q_operator.ry(2 * angle, 0)

# construct via Grover operator
from qiskit.circuit.library import GroverOperator
oracle = QuantumCircuit(1)
oracle.z(0)  # good state = the qubit is in state |1>
q_operator = GroverOperator(oracle, state_preparation=a_operator)

# use default construction in QAE
q_operator = None

ae = AmplitudeEstimation(a_operator, q_operator)

• Add the possibility to compute Conditional Value at Risk (CVaR) expectation values.

Given a diagonal observable H, often corresponding to the objective function of an optimization problem, we are often not as interested in minimizing the average energy of our observed measurements. In this context, we are satisfied if at least some of our measurements achieve low energy. (Note that this is emphatically not the case for chemistry problems).

To this end, one might consider using the best observed sample as a cost function during variational optimization. The issue here, is that this can result in a non-smooth optimization surface. To resolve this issue, we can smooth the optimization surface by using not just the best observed sample, but instead average over some fraction of best observed samples. This is exactly what the CVaR estimator accomplishes [1].

Let $$\alpha$$ be a real number in $$[0,1]$$ which specifies the fraction of best observed samples which are used to compute the objective function. Observe that if $$\alpha = 1$$, CVaR is equivalent to a standard expectation value. Similarly, if $$\alpha = 0$$, then CVaR corresponds to using the best observed sample. Intermediate values of $$\alpha$$ interpolate between these two objective functions.

The functionality to use CVaR is included into the operator flow through a new subclass of OperatorStateFn called CVaRMeasurement. This new StateFn object is instantied in the same way as an OperatorMeasurement with the exception that it also accepts an alpha parameter and that it automatically enforces the is_measurement attribute to be True. Observe that it is unclear what a CVaRStateFn would represent were it not a measurement.

Examples:

qc = QuantumCircuit(1)
qc.h(0)
op = CVaRMeasurement(Z, alpha=0.5) @ CircuitStateFn(primitive=qc, coeff=1.0)
result = op.eval()


Similarly, an operator corresponding to a standard expectation value can be converted into a CVaR expectation using the CVaRExpectation converter.

Examples:

qc = QuantumCircuit(1)
qc.h(0)
op = ~StateFn(Z) @ CircuitStateFn(primitive=qc, coeff=1.0)
cvar_expecation = CVaRExpectation(alpha=0.1).convert(op)
result = cvar_expecation.eval()


See [1] for additional details regarding this technique and it’s empircal performance.

References:

[1]: Barkoutsos, P. K., Nannicini, G., Robert, A., Tavernelli, I., and Woerner, S.,

《Improving Variational Quantum Optimization using CVaR》 arXiv:1907.04769

• New interface Eigensolver for Eigensolver algorithms.

• An interface for excited states calculation has been added to the chemistry module. It is now easier for the user to create a general excited states calculation. This calculation is based on a Driver which provides the relevant information about the molecule, a Transformation which provides the information about the mapping of the problem into a qubit Hamiltonian, and finally a Solver. The Solver is the specific way which the excited states calculation is done (the algorithm). This structure follows the one of the ground state calculations. The results are modified to take lists of expectation values instead of a single one. The QEOM and NumpyEigensolver are adapted to the new structure. A factory is introduced to run a numpy eigensolver with a specific filter (to target states of specific symmetries).

• In addition to the workflows for solving Fermionic problems, interfaces for calculating Bosonic ground and excited states have been added. In particular we introduced a full interface for running vibronic structure calculations.

• The OrbitalOptimizationVQE has been added as new ground state solver in the chemistry module. This solver allows for the simulatneous optimization of the variational parameters and the orbitals of the molecule. The algorithm is introduced in Sokolov et al., The Journal of Chemical Physics 152 (12).

• A new algorithm has been added: the Born Openheimer Potential Energy surface for the calculation of potential energy surface along different degrees of freedom of the molecule. The algorithm is called BOPESSampler. It further provides functionalities of fitting the potential energy surface to an analytic function of predefined potentials.

• A feasibility check of the obtained solution has been added to all optimizers in the optimization stack. This has been implemented by adding two new methods to QuadraticProgram: * get_feasibility_info(self, x: Union[List[float], np.ndarray]) accepts an array and returns whether this solution is feasible and a list of violated variables(violated bounds) and a list of violated constraints. * is_feasible(self, x: Union[List[float], np.ndarray]) accepts an array and returns whether this solution is feasible or not.

• Add circuit-based versions of FixedIncomeExpectedValue, EuropeanCallDelta, GaussianConditionalIndependenceModel and EuropeanCallExpectedValue to qiskit.finance.applications.

• Gradient Framework. qiskit.operators.gradients Given an operator that represents either a quantum state resp. an expectation value, the gradient framework enables the evaluation of gradients, natural gradients, Hessians, as well as the Quantum Fisher Information.

Suppose a parameterized quantum state |ψ(θ)〉 = V(θ)|ψ〉 with input state |ψ〉 and parametrized Ansatz V(θ), and an Operator O(ω).

Gradients: We want to compute $$d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dω$$ resp. $$d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ$$ resp. $$d⟨ψ(θ)|i〉⟨i|ψ(θ)〉/ dθ$$.

The last case corresponds to the gradient w.r.t. the sampling probabilities of |ψ(θ). These gradients can be computed with different methods, i.e. a parameter shift, a linear combination of unitaries and a finite difference method.

Examples:

x = Parameter('x')
ham = x * X
a = Parameter('a')

q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.p(params[0], q[0])
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)

value_dict = {x: 0.1, a: np.pi / 4}

params=[a])


Hessians: We want to compute $$d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dω^2$$ resp. $$d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ^2$$ resp. $$d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθdω$$ resp. $$d^2⟨ψ(θ)|i〉⟨i|ψ(θ)〉/ dθ^2$$.

The last case corresponds to the Hessian w.r.t. the sampling probabilities of |ψ(θ). Just as the first order gradients, the Hessians can be evaluated with different methods, i.e. a parameter shift, a linear combination of unitaries and a finite difference method. Given a tuple of parameters Hessian().convert(op, param_tuple) returns the value for the second order derivative. If a list of parameters is given Hessian().convert(op, param_list) returns the full Hessian for all the given parameters according to the given parameter order.

QFI: The Quantum Fisher Information QFI is a metric tensor which is representative for the representation capacity of a parameterized quantum state |ψ(θ)〉 = V(θ)|ψ〉 generated by an input state |ψ〉 and a parametrized Ansatz V(θ). The entries of the QFI for a pure state read $$[QFI]kl= Re[〈∂kψ|∂lψ〉−〈∂kψ|ψ〉〈ψ|∂lψ〉] * 4$$.

Just as for the previous derivative types, the QFI can be computed using different methods: a full representation based on a linear combination of unitaries implementation, a block-diagonal and a diagonal representation based on an overlap method.

Examples:

q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.p(params[0], q[0])
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)

value_dict = {x: 0.1, a: np.pi / 4}
qfi = QFI('lin_comb_full').convert(operator=CircuitStateFn(primitive=qc, coeff=1.), params=[a])
qfi.assign_parameters(value_dict).eval()


The combination of the QFI and the gradient lead to a special form of a gradient, namely

NaturalGradients: The natural gradient is a special gradient method which rescales a gradient w.r.t. a state parameter with the inverse of the corresponding Quantum Fisher Information (QFI) $$QFI^-1 d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ$$. Hereby, we can choose a gradient as well as a QFI method and a regularization method which is used together with a least square solver instead of exact invertion of the QFI:

Examples:

op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)
regularization='ridge').convert(operator=op, params=params)


The gradient framework is also compatible with the optimizers from qiskit.aqua.components.optimizers. The derivative classes come with a gradient_wrapper() function which returns the corresponding callable.

• Introduces transformations for the fermionic and bosonic transformation of a problem instance. Transforms the fermionic operator to qubit operator. Respective class for the transformation is fermionic_transformation Introduces in algorithms ground_state_solvers for the calculation of ground state properties. The calculation can be done either using an MinimumEigensolver or using AdaptVQE Introduces chemistry/results where the eigenstate_result and the electronic_structure_result are also used for the algorithms. Introduces Minimum Eigensolver factories minimum_eigensolver_factories where chemistry specific minimum eigensolvers can be initialized Introduces orbital optimization vqe oovqe as a ground state solver for chemistry applications

• New Algorithm result classes:

Grover method _run() returns class GroverResult. AmplitudeEstimation method _run() returns class AmplitudeEstimationResult. IterativeAmplitudeEstimation method _run() returns class IterativeAmplitudeEstimationResult. MaximumLikelihoodAmplitudeEstimation method _run() returns class MaximumLikelihoodAmplitudeEstimationResult.

All new result classes are backwards compatible with previous result dictionary.

• New Linear Solver result classes:

HHL method _run() returns class HHLResult. NumPyLSsolver method _run() returns class NumPyLSsolverResult.

All new result classes are backwards compatible with previous result dictionary.

• MinimumEigenOptimizationResult now exposes properties: samples and eigensolver_result. The latter is obtained from the underlying algorithm used by the optimizer and specific to the algorithm. RecursiveMinimumEigenOptimizer now returns an instance of the result class RecursiveMinimumEigenOptimizationResult which in turn may contains intermediate results obtained from the underlying algorithms. The dedicated result class exposes properties replacements and history that are specific to this optimizer. The depth of the history is managed by the history parameter of the optimizer.

• GroverOptimizer now returns an instance of GroverOptimizationResult and this result class exposes properties operation_counts, n_input_qubits, and n_output_qubits directly. These properties are not available in the raw_results dictionary anymore.

• SlsqpOptimizer now returns an instance of SlsqpOptimizationResult and this result class exposes additional properties specific to the SLSQP implementation.

• Support passing QuantumCircuit objects as generator circuits into the QuantumGenerator.

• Removes the restriction to real input vectors in CircuitStateFn.from_vector. The method calls extensions.Initialize. The latter explicitly supports (in API and documentation) complex input vectors. So this restriction seems unnecessary.

• Simplified AbelianGrouper using a graph coloring algorithm of retworkx. It is faster than the numpy-based coloring algorithm.

• Allow calling eval on state function objects with no argument, which returns the VectorStateFn representation of the state function. This is consistent behavior with OperatorBase.eval, which returns the MatrixOp representation, if no argument is passed.

• Adds max_iterations to the VQEAdapt class in order to allow limiting the maximum number of iterations performed by the algorithm.

• VQE expectation computation with Aer qasm_simulator now defaults to a computation that has the expected shot noise behavior. The special Aer snapshot based computation, that is much faster, with the ideal output similar to state vector simulator, may still be chosen but like before Aqua 0.7 it now no longer defaults to this but can be chosen.

• Extension of the previous Analytic Quantum Gradient Descent (AQGD) classical optimizer with the AQGD with Epochs. Now AQGD performs the gradient descent optimization with a momentum term, analytic gradients, and an added customized step length schedule for parametrized quantum gates. Gradients are computed 《analytically》 using the quantum circuit when evaluating the objective function.

• The deprecated support for running qiskit-aqua with Python 3.5 has been removed. To use qiskit-aqua >=0.8.0 you will now need at least Python 3.6. If you are using Python 3.5 the last version which will work is qiskit-aqua 0.7.x.

• Added retworkx as a new dependency.

##### Deprecation Notes¶
• The i_objective argument of the amplitude estimation algorithms has been renamed to objective_qubits.

• TransformationType

• QubitMappingType

• Deprecate the CircuitFactory and derived types. The CircuitFactory has been introduced as temporary class when the QuantumCircuit missed some features necessary for applications in Aqua. Now that the circuit has all required functionality, the circuit factory can be removed. The replacements are shown in the following table.

Circuit factory class               | Replacement
------------------------------------+-----------------------------------------------
CircuitFactory                      | use QuantumCircuit
|
UncertaintyModel                    | -
UnivariateDistribution              | -
MultivariateDistribution            | -
NormalDistribution                  | qiskit.circuit.library.NormalDistribution
MultivariateNormalDistribution      | qiskit.circuit.library.NormalDistribution
LogNormalDistribution               | qiskit.circuit.library.LogNormalDistribution
MultivariateLogNormalDistribution   | qiskit.circuit.library.LogNormalDistribution
UniformDistribution                 | qiskit.circuit.library.UniformDistribution
MultivariateUniformDistribution     | qiskit.circuit.library.UniformDistribution
UnivariateVariationalDistribution   | use parameterized QuantumCircuit
MultivariateVariationalDistribution | use parameterized QuantumCircuit
|
UncertaintyProblem                  | -
UnivariateProblem                   | -
MultivariateProblem                 | -
UnivariatePiecewiseLinearObjective  | qiskit.circuit.library.LinearAmplitudeFunction

• The ising convert classes qiskit.optimization.converters.QuadraticProgramToIsing and qiskit.optimization.converters.IsingToQuadraticProgram have been deprecated and will be removed in a future release. Instead the qiskit.optimization.QuadraticProgram methods to_ising() and from_ising() should be used instead.

• Deprecate the WeightedSumOperator which has been ported to the circuit library as WeightedAdder in qiskit.circuit.library.

• Core Hamiltonian class is deprecated in favor of the FermionicTransformation Chemistry Operator class is deprecated in favor of the tranformations minimum_eigen_solvers/vqe_adapt is also deprecated and moved as an implementation of the ground_state_solver interface applications/molecular_ground_state_energy is deprecated in favor of ground_state_solver

• Optimizer.SupportLevel nested enum is replaced by OptimizerSupportLevel and Optimizer.SupportLevel was removed. Use, for example, OptimizerSupportLevel.required instead of Optimizer.SupportLevel.required.

• Deprecate the UnivariateVariationalDistribution and MultivariateVariationalDistribution as input to the QuantumGenerator. Instead, plain QuantumCircuit objects can be used.

• Ignored fast and use_nx options of AbelianGrouper.group_subops to be removed in the future release.

• GSLS optimizer class deprecated __init__ parameter max_iter in favor of maxiter. SPSA optimizer class deprecated __init__ parameter max_trials in favor of maxiter. optimize_svm function deprecated max_iters parameter in favor of maxiter. ADMMParameters class deprecated __init__ parameter max_iter in favor of maxiter.

##### 버그 수정¶
• The UCCSD excitation list, comprising single and double excitations, was not being generated correctly when an active space was explicitly provided to UCSSD via the active_(un)occupied parameters.

• For the amplitude estimation algorithms, we define the number of oracle queries as number of times the Q operator/Grover operator is applied. This includes the number of shots. That factor has been included in MLAE and IQAE but was missing in the 〈standard〉 QAE.

• Fix CircuitSampler.convert, so that the is_measurement property is propagated to converted StateFns.

• Fix double calculation of coefficients in :meth~qiskit.aqua.operators.VectorStateFn.to_circuit_op.

• Calling PauliTrotterEvolution.convert on an operator including a term that is a scalar multiple of the identity gave an incorrect circuit, one that ignored the scalar coefficient. This fix includes the effect of the coefficient in the global_phase property of the circuit.

• Make ListOp.num_qubits check that all ops in list have the same num_qubits Previously, the number of qubits in the first operator in the ListOp was returned. With this change, an additional check is made that all other operators also have the same number of qubits.

• Make PauliOp.exp_i() generate the correct matrix with the following changes. 1) There was previously an error in the phase of a factor of 2. 2) The global phase was ignored when converting the circuit to a matrix. We now use qiskit.quantum_info.Operator, which is generally useful for converting a circuit to a unitary matrix, when possible.

• Fixes the cyclicity detection as reported buggy in https://github.com/Qiskit/qiskit-aqua/issues/1184.

#### IBM Q Provider 0.11.0¶

• The deprecated support for running qiskit-ibmq-provider with Python 3.5 has been removed. To use qiskit-ibmq-provider >=0.11.0 you will now need at least Python 3.6. If you are using Python 3.5 the last version which will work is qiskit-ibmq-provider 0.10.x.

• Prior to this release, websockets 7.0 was used for Python 3.6. With this release, websockets 8.0 or above is required for all Python versions. The package requirements have been updated to reflect this.

### 키스킷 0.22.0¶

No change

No change

No change

No change

#### IBM Q 공급자 0.5.0¶

##### 새로운 기능¶
• CQC randomness extractors can now be invoked asynchronously, using methods run_async_ext1() and run_async_ext2(). Each of these methods returns a CQCExtractorJob instance that allows you to check on the job status (using status()) and wait for its result (using block_until_ready()). The qiskit.provider.ibmq.random.CQCExtractor.run() method remains synchronous.

• You can now use the new IBMQ experiment service to query, retrieve, and download experiment related data. Interface to this service is located in the new qiskit.providers.ibmq.experiment package. Note that this feature is still in beta, and not all accounts have access to it. It is also subject to heavy modification in both functionality and API without backward compatibility.

• Two Jupyter magic functions, the IQX dashboard and the backend widget, are updated to display backend reservations. If a backend has reservations scheduled in the next 24 hours, time to the next one and its duration are displayed (e.g. Reservation: in 6 hrs 30 min (60m)). If there is a reservation and the backend is active, the backend status is displayed as active [R].

• Starting from this release, the basis_gates returned by qiskit.providers.ibmq.IBMQBackend.configuration() may differ for each backend. You should update your program if it relies on the basis gates being ['id','u1','u2','u3','cx']. We recommend always using the configuration() method to find backend configuration values instead of hard coding them.

• qiskit-ibmq-provider release 0.10 requires qiskit-terra release 0.15 or above. The package metadata has been updated to reflect the new dependency.

### Qiskit 0.21.0¶

No change

No change

No change

No change

#### IBM Q Provider 0.9.0¶

##### 새로운 기능¶
• You can now access the IBMQ random number services, such as the CQC randomness extractor, using the new package qiskit.providers.ibmq.random. Note that this feature is still in beta, and not all accounts have access to it. It is also subject to heavy modification in both functionality and API without backward compatibility.

##### 버그 수정¶
• Fixes an issue that may raise a ValueError if retrieve_job() is used to retrieve a job submitted via the IBM Quantum Experience Composer.

• IBMQJobManager has been updated so that if a time out happens while waiting for an old job to finish, the time out error doesn’t prevent a new job to be submitted. Fixes #737

### Qiskit 0.20.1¶

#### 테라 0.15.2¶

##### 버그 수정¶
• When accessing the definition attribute of a parameterized Gate instance, the generated QuantumCircuit had been generated with an invalid ParameterTable, such that reading from QuantumCircuit.parameters or calling QuantumCircuit.bind_parameters would incorrectly report the unbound parameters. This has been resolved.

• SXGate().inverse() had previously returned an 〈sx_dg〉 gate with a correct definition but incorrect to_matrix. This has been updated such that SXGate().inverse() returns an SXdgGate() and vice versa.

• Instruction.inverse(), when not overridden by a subclass, would in some cases return a Gate instance with an incorrect to_matrix method. The instances of incorrect to_matrix methods have been removed.

• For C3XGate with a non-zero angle, inverting the gate via C3XGate.inverse() had previously generated an incorrect inverse gate. This has been corrected.

• The MCXGate modes have been updated to return a gate of the same mode when calling .inverse(). This resolves an issue where in some cases, transpiling a circuit containing the inverse of an MCXVChain gate would raise an error.

• Previously, when creating a multiply controlled phase gate via PhaseGate.control, an MCU1Gate gate had been returned. This has been had corrected so that an MCPhaseGate is returned.

• Previously, attempting to decompose a circuit containing an MCPhaseGate would raise an error due to an inconsistency in the definition of the MCPhaseGate. This has been corrected.

• QuantumCircuit.compose and DAGCircuit.compose had, in some cases, incorrectly translated conditional gates if the input circuit contained more than one ClassicalRegister. This has been resolved.

• Fixed an issue when creating a qiskit.result.Counts object from an empty data dictionary. Now this will create an empty Counts object. The most_frequent() method is also updated to raise a more descriptive exception when the object is empty. Fixes #5017

• Extending circuits with differing registers updated the qregs and cregs properties accordingly, but not the qubits and clbits lists. As these are no longer generated from the registers but are cached lists, this lead to a discrepancy of registers and bits. This has been fixed and the extend method explicitly updates the cached bit lists.

• Fix bugs of the concrete implementations of meth:~qiskit.circuit.ControlledGate.inverse method which do not preserve the ctrl_state parameter.

• A bug was fixed that caused long pulse schedules to throw a recursion error.

No change

No change

No change

No change

### Qiskit 0.20.0¶

#### Terra 0.15.1¶

##### 도입¶

The 0.15.0 release includes several new features and bug fixes. Some highlights for this release are:

This release includes the introduction of arbitrary basis translation to the transpiler. This includes support for directly targeting a broader range of device basis sets, e.g. backends implementing RZ, RY, RZ, CZ or iSwap gates.

The QuantumCircuit class now tracks global phase. This means controlling a circuit which has global phase now correctly adds a relative phase, and gate matrix definitions are now exact rather than equal up to a global phase.

##### 새로운 기능¶
• Implementations of the multi-controlled X Gate ( MCXGrayCode, MCXRecursive, and MCXVChain) have had their name properties changed to more accurately describe their implementation: mcx_gray, mcx_recursive, and mcx_vchain respectively. Previously, these gates shared the name mcx with MCXGate, which caused these gates to be incorrectly transpiled and simulated.

• By default the preset passmanagers in qiskit.transpiler.preset_passmanagers are using UnrollCustomDefinitions and BasisTranslator to handle basis changing instead of the previous default Unroller. This was done because the new passes are more flexible and allow targeting any basis set, however the output may differ. To use the previous default you can set the translation_method kwarg on transpile() to 'unroller'.

• The qiskit.converters.circuit_to_gate() and :funcqiskit.converters.circuit_to_instruction converter functions had previously automatically included the generated gate or instruction in the active SessionEquivalenceLibrary. These converters now accept an optional equivalence_library keyword argument to specify if and where the converted instances should be registered. The default behavior has changed to not register the converted instance.

• The default value of the cregbundle kwarg for the qiskit.circuit.QuantumCircuit.draw() method and qiskit.visualization.circuit_drawer() function has been changed to True. This means that by default the classical bits in the circuit diagram will now be bundled by default, for example:

from qiskit.circuit import QuantumCircuit

circ = QuantumCircuit(4)
circ.x(0)
circ.h(1)
circ.measure_all()
circ.draw(output='mpl')


If you want to have your circuit drawing retain the previous behavior and show each classical bit in the diagram you can set the cregbundle kwarg to False. For example:

from qiskit.circuit import QuantumCircuit

circ = QuantumCircuit(4)
circ.x(0)
circ.h(1)
circ.measure_all()
circ.draw(output='mpl', cregbundle=False)

• Schedule plotting with qiskit.pulse.Schedule.draw() and qiskit.visualization.pulse_drawer() will no longer display the event table by default. This can be reenabled by setting the table kwarg to True.

• The pass RemoveResetInZeroState was previously included in the preset pass manager level_0_pass_manager() which was used with the optimization_level=0 for transpile() and execute() functions. However, RemoveResetInZeroState is an optimization pass and should not have been included in optimization level 0 and was removed. If you need to run transpile() with RemoveResetInZeroState either use a custom pass manager or optimization_level 1, 2, or 3.

• The deprecated kwarg line_length for the qiskit.visualization.circuit_drawer() function and qiskit.circuit.QuantumCircuit.draw() method has been removed. It had been deprecated since the 0.10.0 release. Instead you can use the fold kwarg to adjust the width of the circuit diagram.

• The 'mpl' output mode for the qiskit.circuit.QuantumCircuit.draw() method and circuit_drawer() now requires the pylatexenc library to be installed. This was already an optional dependency for visualization, but was only required for the 'latex' output mode before. It is now also required for the matplotlib drawer because it is needed to handle correctly sizing gates with matplotlib’s mathtext labels for gates.

• The deprecated get_tokens methods for the qiskit.qasm.Qasm and qiskit.qasm.QasmParser has been removed. These methods have been deprecated since the 0.9.0 release. The qiskit.qasm.Qasm.generate_tokens() and qiskit.qasm.QasmParser.generate_tokens() methods should be used instead.

• The deprecated kwarg channels_to_plot for qiskit.pulse.Schedule.draw(), qiskit.pulse.Instruction.draw(), qiskit.visualization.pulse.matplotlib.ScheduleDrawer.draw and pulse_drawer() has been removed. The kwarg has been deprecated since the 0.11.0 release and was replaced by the channels kwarg, which functions identically and should be used instead.

• The deprecated circuit_instruction_map attribute of the qiskit.providers.models.PulseDefaults class has been removed. This attribute has been deprecated since the 0.12.0 release and was replaced by the instruction_schedule_map attribute which can be used instead.

• The union method of Schedule and Instruction have been deprecated since the 0.12.0 release and have now been removed. Use qiskit.pulse.Schedule.insert() and qiskit.pulse.Instruction.meth() methods instead with the kwargtime=0.

• The deprecated scaling argument to the draw method of Schedule and Instruction has been replaced with scale since the 0.12.0 release and now has been removed. Use the scale kwarg instead.

• The deprecated period argument to qiskit.pulse.library functions have been replaced by freq since the 0.13.0 release and now removed. Use the freq kwarg instead of period.

• The qiskit.pulse.commands module containing Commands classes was deprecated in the 0.13.0 release and has now been removed. You will have to upgrade your Pulse code if you were still using commands. For example:

Old

New

Command(args)(channel)

Instruction(args, channel)

Acquire(duration)(AcquireChannel(0))

Acquire(duration, AcquireChannel(0))

Delay(duration)(channel)

Delay(duration, channel)

FrameChange(angle)(DriveChannel(0))

# FrameChange was also renamed
ShiftPhase(angle, DriveChannel(0))

Gaussian(...)(DriveChannel(0))

# Pulses need to be Playd
Play(Gaussian(...), DriveChannel(0))

• All classes and function in the qiskit.tool.qi module were deprecated in the 0.12.0 release and have now been removed. Instead use the qiskit.quantum_info module and the new methods and classes that it has for working with quantum states and operators.

• The qiskit.quantum_info.basis_state and qiskit.quantum_info.projector functions are deprecated as of Qiskit Terra 0.12.0 as are now removed. Use the qiskit.quantum_info.QuantumState and its derivatives qiskit.quantum_info.Statevector and qiskit.quantum_info.DensityMatrix to work with states.

• The interactive plotting functions from qiskit.visualization, iplot_bloch_multivector, iplot_state_city, iplot_state_qsphere, iplot_state_hinton, iplot_histogram, iplot_state_paulivec now are just deprecated aliases for the matplotlib based equivalents and are no longer interactive. The hosted static JS code that these functions relied on has been removed and they no longer could work. A normal deprecation wasn’t possible because the site they depended on no longer exists.

• The validation components using marshmallow from qiskit.validation have been removed from terra. Since they are no longer used to build any objects in terra.

• The marshmallow schema classes in qiskit.result have been removed since they are no longer used by the qiskit.result.Result class.

• The output of the to_dict() method for the qiskit.result.Result class is no longer in a format for direct JSON serialization. Depending on the content contained in instances of these classes there may be types that the default JSON encoder doesn’t know how to handle, for example complex numbers or numpy arrays. If you’re JSON serializing the output of the to_dict() method directly you should ensure that your JSON encoder can handle these types.

• The option to acquire multiple qubits at once was deprecated in the 0.12.0 release and is now removed. Specifically, the init args mem_slots and reg_slots have been removed from qiskit.pulse.instructions.Acquire, and channel, mem_slot and reg_slot will raise an error if a list is provided as input.

• Support for the use of the USE_RETWORKX environment variable which was introduced in the 0.13.0 release to provide an optional fallback to the legacy networkx based qiskit.dagcircuit.DAGCircuit implementation has been removed. This flag was only intended as provide a relief valve for any users that encountered a problem with the new implementation for one release during the transition to retworkx.

• The module within qiskit.pulse responsible for schedule->schedule transformations has been renamed from reschedule.py to transforms.py. The previous import path has been deprecated. To upgrade your code:

from qiskit.pulse.rescheduler import <X>


should be replaced by:

from qiskit.pulse.transforms import <X>

• In previous releases a PassManager did not allow TransformationPass classes to modify the PropertySet. This restriction has been lifted so a TransformationPass class now has read and write access to both the PropertySet and DAGCircuit during run(). This change was made to more efficiently facilitate TransformationPass classes that have an internal state which may be necessary for later passes in the PassManager. Without this change a second redundant AnalysisPass would have been necessary to recreate the internal state, which could add significant overhead.

##### Other Notes¶
• The qiskit.result.Result class which was previously constructed using the marshmallow library has been refactored to not depend on marshmallow anymore. This new implementation should be a seamless transition but some specific behavior that was previously inherited from marshmallow may not work. Please file issues for any incompatibilities found.

#### Aer 0.6.1¶

##### 도입¶

This 0.6.0 release includes numerous performance improvements for all simulators in the Aer provider and significant changes to the build system when building from source. The main changes are support for SIMD vectorization, approximation in the matrix product state method via bond-dimension truncation, more efficient Pauli expectation value computation, and greatly improved efficiency in Python conversion of C++ result objects. The build system was upgraded to use the Conan to manage common C++ dependencies when building from source.

##### 새로운 기능¶
• Add density matrix snapshot support to 《statevector》 and 《statevector_gpu》 methods of the QasmSimulator.

• Allow density matrix snapshots on specific qubits, not just all qubits. This computes the partial trace of the state over the remaining qubits.

• Adds Pauli expectation value snapshot support to the 《density_matrix》 simulation method of the qiskit.providers.aer.QasmSimulator. Add snapshots to circuits using the qiskit.providers.aer.extensions.SnapshotExpectationValue extension.

• Greatly improves performance of the Pauli expectation value snapshot algorithm for the 《statevector》, 《statevector_gpu, 《density_matrix》, and 《density_matrix_gpu》 simulation methods of the qiskit.providers.aer.QasmSimulator.

• Enable the gate-fusion circuit optimization from the qiskit.providers.aer.QasmSimulator in both the qiskit.providers.aer.StatevectorSimulator and qiskit.providers.aer.UnitarySimulator backends.

• Improve the performance of average snapshot data in simulator results. This effects probability, Pauli expectation value, and density matrix snapshots using the following extensions:

• Add move constructor and improve memory usage of the C++ matrix class to minimize copies of matrices when moving output of simulators into results.

• Improve performance of unitary simulator.

• Add approximation to the 《matrix_product_state》 simulation method of the QasmSimulator to limit the bond-dimension of the MPS.

There are two modes of approximation. Both discard the smallest Schmidt coefficients following the SVD algorithm. There are two parameters that control the degree of approximation: "matrix_product_state_max_bond_dimension" (int): Sets a limit on the number of Schmidt coefficients retained at the end of the svd algorithm. Coefficients beyond this limit will be discarded. (Default: None, i.e., no limit on the bond dimension). "matrix_product_state_truncation_threshold" (double): Discard the smallest coefficients for which the sum of their squares is smaller than this threshold. (Default: 1e-16).

• Improve the performance of measure sampling when using the 《matrix_product_state》 QasmSimulator simulation method.

• Add support for Delay, Phase and SetPhase pulse instructions to the qiskit.providers.aer.PulseSimulator.

• Improve the performance of the qiskit.providers.aer.PulseSimulator by caching calls to RHS function

• Introduce alternate DE solving methods, specifiable through backend_options in the qiskit.providers.aer.PulseSimulator.

• Improve performance of simulator result classes by using move semantics and removing unnecessary copies that were happening when combining results from separate experiments into the final result object.

• Greatly improve performance of pybind11 conversion of simulator results by using move semantics where possible, and by moving vector and matrix results to Numpy arrays without copies.

• Change the RNG engine for simulators from 32-bit Mersenne twister to 64-bit Mersenne twister engine.

• Improves the performance of the 《statevector》 simulation method of the qiskit.providers.aer.QasmSimulator and qiskit.providers.aer.StatevectorSimulator by using SIMD intrinsics on systems that support the AVX2 instruction set. AVX2 support is automatically detected and enabled at runtime.

• Changes the build system to use the Conan package manager. This tool will handle most of the dependencies needed by the C++ source code. Internet connection may be needed for the first build or when dependencies are added or updated, in order to download the required packages if they are not in your Conan local repository.

When building the standalone version of qiskit-aer you must install conan first with:

pip install conan

• 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.

• Adds an OpSet object to the base simulator State class to allow easier validation of instructions, gates, and snapshots supported by simulators.

• Refactor OpSet class. Moved OpSet to separate header file and add contains and difference methods based on std::set::contains and std::algorithm::set_difference. These replace the removed invalid and validate instructions from OpSet, but with the order reversed. It returns a list of other ops not in current opset rather than opset instructions not in the other.

• Improves how measurement sampling optimization is checked. The expensive part of this operation is now done once during circuit construction where rather than multiple times during simulation for when checking memory requirements, simulation method, and final execution.

##### 버그 수정¶
• 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.

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

• Fixes a bug causing incorrect channel evaluation in the qiskit.providers.aer.PulseSimulator.

• Fixes several minor bugs for Hamiltonian parsing edge cases in the qiskit.providers.aer.pulse.system_models.hamiltonian_model.HamiltonianModel class.

#### Ignis 0.4.0¶

##### 도입¶

The main change made in this release is a refactor of the Randomized Benchmarking code to integrate the updated Clifford class qiskit.quantum_info.Clifford from Terra and to improve the CNOT-Dihedral class.

##### 새로운 기능¶
• The qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() function was refactored to use the updated Clifford class Clifford, to allow efficient Randomized Benchmarking (RB) on Clifford sequences with more than 2 qubits. In addition, the code of the CNOT-Dihedral class qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral was refactored to make it more efficient, by using numpy arrays, as well not using pre-generated pickle files storing all the 2-qubit group elements. The qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() function has a new kwarg rand_seed which can be used to specify a seed for the random number generator used to generate the RB circuits. This can be useful for having a reproducible circuit.

• The qiskit.ignis.verification.qv_circuits() function has a new kwarg seed which can be used to specify a seed for the random number generator used to generate the Quantum Volume circuits. This can be useful for having a reproducible circuit.

• The qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() function is now using the updated Clifford class Clifford and the updated CNOT-Dihedral class qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral to construct its output instead of using pre-generated group tables for the Clifford and CNOT-Dihedral group elements, which were stored in pickle files. This may result in subtle differences from the output from the previous version.

• 요구사항 목록에 새로운 요구사항 scikit-learn 가 추가되었다. 이 종속성은 0.3.0릴리스에 추가된 것이지만 해당 릴리스에서 종속성이 제대로 표시되지 않았다. 이는 qiskit.ignis.measurement.discriminator.iq_discriminators 모듈이 import될때 ImportError를 야기할 수 있다. 이제 종속성이 올바르게 리스트에 추가되었으므로 scikit-learn을 사용할 때는 qiskit-ignis이 함께 설치될 것이다.

• The qiskit.ignis.verification.qv_circuits() function is now using the circuit library class QuantumVolume to construct its output instead of building the circuit from scratch. This may result in subtle differences from the output from the previous version.

• Tomography fitters can now also get list of Result objects instead of a single Result as requested in issue #320.

##### Deprecation Notes¶
• The kwarg interleaved_gates for the qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() function has been deprecated and will be removed in a future release. It is superseded by interleaved_elem. The helper functions qiskit.ignis.verification.randomized_benchmarking.BasicUtils, qiskit.ignis.verification.randomized_benchmarking.CliffordUtils and qiskit.ignis.verification.randomized_benchmarking.DihedralUtils were deprecated. These classes are superseded by qiskit.ignis.verification.randomized_benchmarking.RBgroup that handles the group operations needed for RB. The class qiskit.ignis.verification.randomized_benchmarking.Clifford is superseded by Clifford.

• The kwargs qr and cr for the qiskit.ignis.verification.qv_circuits() function have been deprecated and will be removed in a future release. These kwargs were documented as being used for specifying a qiskit.circuit.QuantumRegister and qiskit.circuit.ClassicalRegister to use in the generated Quantum Volume circuits instead of creating new ones. However, the parameters were never actually respected and a new Register would always be created regardless of whether they were set or not. This behavior is unchanged and these kwargs still do not have any effect, but are being deprecated prior to removal to avoid a breaking change for users who may have been setting either.

• Support for passing in subsets of qubits as a list in the qubit_lists parameter for the qiskit.ignis.verification.qv_circuits() function has been deprecated and will removed in a future release. In the past this was used to specify a layout to run the circuit on a device. In other words if you had a 5 qubit device and wanted to run a 2 qubit QV circuit on qubits 1, 3, and 4 of that device. You would pass in [1, 3, 4] as one of the lists in qubit_lists, which would generate a 5 qubit virtual circuit and have qv applied to qubits 1, 3, and 4 in that virtual circuit. However, this functionality is not necessary and overlaps with the concept of initial_layout in the transpiler and whether a circuit has been embedded with a layout set. Moving forward instead you should just run transpile() or execute() with initial layout set to do this. For example, running the above example would become:

from qiskit import execute
from qiskit.ignis.verification import qv_circuits

initial_layout = [1, 3, 4]
qv_circs, _ = qv_circuits([list(range3)])
execute(qv_circuits, initial_layout=initial_layout)

##### 버그 수정¶
• Fix a bug of the position of measurement pulses inserted by py:func:qiskit.ignis.characterization.calibrations.pulse_schedules.drag_schedules. Fixes #465

#### Aqua 0.7.5¶

##### 새로운 기능¶
• Removed soft dependency on CPLEX in ADMMOptimizer. Now default optimizers used by ADMMOptimizer are MinimumEigenOptimizer for QUBO problems and SlsqpOptimizer as a continuous optimizer. You can still use CplexOptimizer as an optimizer for ADMMOptimizer, but it should be set explicitly.

• New Yahoo! finance provider created.

• Introduced QuadraticProgramConverter which is an abstract class for converters. Added convert/interpret methods for converters instead of encode/decode. Added to_ising and from_ising to QuadraticProgram class. Moved all parameters from convert to constructor except name. Created setter/getter for converter parameters. Added auto_define_penalty and interpret forLinearEqualityToPenalty. Now error messages of converters are more informative.

• Added an SLSQP optimizer qiskit.optimization.algorithms.SlsqpOptimizer as a wrapper of the corresponding SciPy optimization method. This is a classical optimizer, does not depend on quantum algorithms and may be used as a replacement for CobylaOptimizer.

• Cobyla optimizer has been modified to accommodate a multi start feature introduced in the SLSQP optimizer. By default, the optimizer does not run in the multi start mode.

• The SummedOp does a mathematically more correct check for equality, where expressions such as X + X == 2*X and X + Z == Z + X evaluate to True.

##### Deprecation Notes¶
• GSLS optimizer class deprecated __init__ parameter max_iter in favor of maxiter. SPSA optimizer class deprecated __init__ parameter max_trials in favor of maxiter. optimize_svm function deprecated max_iters parameter in favor of maxiter. ADMMParameters class deprecated __init__ parameter max_iter in favor of maxiter.

• The ising convert classes qiskit.optimization.converters.QuadraticProgramToIsing and qiskit.optimization.converters.IsingToQuadraticProgram have been deprecated and will be removed in a future release. Instead the qiskit.optimization.QuadraticProgram methods to_ising() and from_ising() should be used instead.

• The pprint_as_string method for qiskit.optimization.QuadraticProgram has been deprecated and will be removed in a future release. Instead you should just run .pprint_as_string() on the output from to_docplex()

• The prettyprint method for qiskit.optimization.QuadraticProgram has been deprecated and will be removed in a future release. Instead you should just run .prettyprint() on the output from to_docplex()

##### 버그 수정¶
• Changed in python version 3.8: On macOS, the spawn start method is now the default. The fork start method should be considered unsafe as it can lead to crashes in subprocesses. However P_BFGS doesn’t support spawn, so we revert to single process. Refer to #1109 <https://github.com/Qiskit/qiskit-aqua/issues/1109> for more details.

• Binding parameters in the CircuitStateFn did not copy the value of is_measurement and always set is_measurement=False. This has been fixed.

• Previously, SummedOp.to_matrix_op built a list MatrixOp’s (with numpy matrices) and then summed them, returning a single MatrixOp. Some algorithms (for example vqe) require summing thousands of matrices, which exhausts memory when building the list of matrices. With this change, no list is constructed. Rather, each operand in the sum is converted to a matrix, added to an accumulator, and discarded.

• Changing backends in VQE from statevector to qasm_simulator or real device was causing an error due to CircuitSampler incompatible reuse. VQE was changed to always create a new CircuitSampler and create a new expectation in case not entered by user. Refer to #1153 <https://github.com/Qiskit/qiskit-aqua/issues/1153> for more details.

• Exchange and Wikipedia finance providers were fixed to correctly handle Quandl data. Refer to #775 <https://github.com/Qiskit/qiskit-aqua/issues/775> for more details. Fixes a divide by 0 error on finance providers mean vector and covariance matrix calculations. Refer to #781 <https://github.com/Qiskit/qiskit-aqua/issues/781> for more details.

• The ListOp.combo_fn property has been lost in several transformations, such as converting to another operator type, traversing, reducing or multiplication. Now this attribute is propagated to the resulting operator.

• The evaluation of some operator expressions, such as of SummedOps and evaluations with the CircuitSampler did not treat coefficients correctly or ignored them completely. E.g. evaluating ~StateFn(0 * (I + Z)) @ Plus did not yield 0 or the normalization of ~StateFn(I) @ ((Plus + Minus) / sqrt(2)) missed a factor of sqrt(2). This has been fixed.

• OptimizationResult included some public setters and class variables were Optional. This fix makes all class variables read-only so that mypy and pylint can check types more effectively. MinimumEigenOptimizer.solve generated bitstrings in a result as str. This fix changed the result into List[float] as the other algorithms do. Some public classes related to optimization algorithms were missing in the documentation of qiskit.optimization.algorithms. This fix added all such classes to the docstring. #1131 <https://github.com/Qiskit/qiskit-aqua/issues/1131> for more details.

• OptimizationResult.__init__ did not check whether the sizes of x and variables match or not (they should match). This fix added the check to raise an error if they do not match and fixes bugs detected by the check. This fix also adds missing unit tests related to OptimizationResult.variable_names and OptimizationResult.variables_dict in test_converters. #1167 <https://github.com/Qiskit/qiskit-aqua/issues/1167> for more details.

• Fix parameter binding in the OperatorStateFn, which did not bind parameters of the underlying primitive but just the coefficients.

• op.eval(other), where op is of type OperatorBase, sometimes silently returns a nonsensical value when the number of qubits in op and other are not equal. This fix results in correct behavior, which is to throw an error rather than return a value, because the input in this case is invalid.

• The construct_circuit method of VQE previously returned the expectation value to be evaluated as type OperatorBase. This functionality has been moved into construct_expectation and construct_circuit returns a list of the circuits that are evaluated to compute the expectation value.

#### IBM Q Provider 0.8.0¶

##### Deprecation Notes¶
• Use of Qconfig.py to save IBM Quantum Experience credentials is deprecated and will be removed in the next release. You should use qiskitrc (the default) instead.

##### 버그 수정¶
• Fixes an issue wherein a call to qiskit.providers.ibmq.IBMQBackend.jobs() can hang if the number of jobs being returned is large. Fixes #674

• Fixes an issue which would raise a ValueError when building error maps in Jupyter for backends that are offline. Fixes #706

• qiskit.providers.ibmq.IBMQBackend.jobs() will now return the correct list of IBMQJob objects when the status kwarg is set to 'RUNNING'.

• The package metadata has been updated to properly reflect the dependency on qiskit-terra >= 0.14.0. This dependency was implicitly added as part of the 0.7.0 release but was not reflected in the package requirements so it was previously possible to install qiskit-ibmq-provider with a version of qiskit-terra which was too old. Fixes #677

### Qiskit 0.19.6¶

변경 없음

변경 없음

#### Ignis 0.3.3¶

• 요구사항 목록에 새로운 요구사항 scikit-learn 가 추가되었다. 이 종속성은 0.3.0릴리스에 추가된 것이지만 해당 릴리스에서 종속성이 제대로 표시되지 않았다. 이는 qiskit.ignis.measurement.discriminator.iq_discriminators 모듈이 import될때 ImportError를 야기할 수 있다. 이제 종속성이 올바르게 리스트에 추가되었으므로 scikit-learn을 사용할 때는 qiskit-ignis이 함께 설치될 것이다.

##### 버그 수정¶
• Fixes an issue in qiskit-ignis 0.3.2 which would raise an ImportError when qiskit.ignis.verification.tomography.fitters.process_fitter was imported without cvxpy being installed.

변경 없음

변경 없음

### Qiskit 0.19.5¶

변경 없음

변경 없음

#### Ignis 0.3.2¶

##### 버그 수정¶
• The qiskit.ignis.verification.TomographyFitter.fit() method has improved detection logic for the default fitter. Previously, the cvx fitter method was used whenever cvxpy was installed. However, it was possible to install cvxpy without an SDP solver that would work for the cvx fitter method. This logic has been reworked so that the cvx fitter method is only used if cvxpy is installed and an SDP solver is present that can be used. Otherwise, the lstsq fitter is used.

• Fixes an edge case in qiskit.ignis.mitigation.measurement.fitters.MeasurementFitter.apply() for input that has invalid or incorrect state labels that don’t match the calibration circuit. Previously, this would not error and just return an empty result. Instead now this case is correctly caught and a QiskitError exception is raised when using incorrect labels.

#### Aqua 0.7.3¶

• The cvxpy dependency which is required for the svm classifier has been removed from the requirements list and made an optional dependency. This is because installing cvxpy is not seamless in every environment and often requires a compiler be installed to run. To use the svm classifier now you’ll need to install cvxpy by either running pip install cvxpy<1.1.0 or to install it with aqua running pip install qiskit-aqua[cvx].

##### 버그 수정¶
• The compose method of the CircuitOp used QuantumCircuit.combine which has been changed to use QuantumCircuit.compose. Using combine leads to the problem that composing an operator with a CircuitOp based on a named register does not chain the operators but stacks them. E.g. composing Z ^ 2 with a circuit based on a 2-qubit named register yielded a 4-qubit operator instead of a 2-qubit operator.

• The MatrixOp.to_instruction method previously returned an operator and not an instruction. This method has been updated to return an Instruction. Note that this only works if the operator primitive is unitary, otherwise an error is raised upon the construction of the instruction.

• The __hash__ method of the PauliOp class used the id() method which prevents set comparisons to work as expected since they rely on hash tables and identical objects used to not have identical hashes. Now, the implementation uses a hash of the string representation inline with the implementation in the Pauli class.

변경 없음

### Qiskit 0.19.4¶

#### Terra 0.14.2¶

• The circuit_to_gate and circuit_to_instruction converters had previously automatically included the generated gate or instruction in the active SessionEquivalenceLibrary. These converters now accept an optional equivalence_library keyword argument to specify if and where the converted instances should be registered. The default behavior is not to register the converted instance.

##### 버그 수정¶
• Implementations of the multi-controlled X Gate (MCXGrayCode, MCXRecursive and MCXVChain) have had their name properties changed to more accurately describe their implementation (mcx_gray, mcx_recursive, and mcx_vchain respectively.) Previously, these gates shared the name mcx with MCXGate, which caused these gates to be incorrectly transpiled and simulated.

• ControlledGate instances with a set ctrl_state were in some cases not being evaluated as equal, even if the compared gates were equivalent. This has been resolved.

• Fixed the SI unit conversion for qiskit.pulse.SetFrequency. The SetFrequency instruction should be in Hz on the frontend and has to be converted to GHz when SetFrequency is converted to PulseQobjInstruction.

• Open controls were implemented by modifying a gate's definition. However, when the gate already exists in the basis, this definition is not used, which yields incorrect circuits sent to a backend. This modifies the unroller to output the definition if it encounters a controlled gate with open controls.

변경 없음

변경 없음

#### Aqua 0.7.2¶

##### 도입¶

VQE expectation computation with Aer qasm_simulator now defaults to a computation that has the expected shot noise behavior.

• cvxpy is now in the requirements list as a dependency for qiskit-aqua. It is used for the quadratic program solver which is used as part of the qiskit.aqua.algorithms.QSVM. Previously cvxopt was an optional dependency that needed to be installed to use this functionality. This is no longer required as cvxpy will be installed with qiskit-aqua.

• For state tomography run as part of qiskit.aqua.algorithms.HHL with a QASM backend the tomography fitter function qiskit.ignis.verification.StateTomographyFitter.fit() now gets called explicitly with the method set to lstsq to always use the least-squares fitting. Previously it would opportunistically try to use the cvx fitter if cvxpy were installed. But, the cvx fitter depends on a specifically configured cvxpy installation with an SDP solver installed as part of cvxpy which is not always present in an environment with cvxpy installed.

• The VQE expectation computation using qiskit-aer’s qiskit.providers.aer.extensions.SnapshotExpectationValue instruction is not enabled by default anymore. This was changed to be the default in 0.7.0 because it is significantly faster, but it led to unexpected ideal results without shot noise (see #1013 for more details). The default has now changed back to match user expectations. Using the faster expectation computation is now opt-in by setting the new include_custom kwarg to True on the qiskit.aqua.algorithms.VQE constructor.

변경 없음

### Qiskit 0.19.3¶

변경 없음

#### Aer 0.5.2¶

##### 버그 수정¶
• Fixed bug with statevector and unitary simulators running a number of (parallel) shots equal to the number of CPU threads instead of only running a single shot.

• Fixes the 《diagonal》 qobj gate instructions being applied incorrectly in the density matrix Qasm Simulator method.

• Fixes bug where conditional gates were not being applied correctly on the density matrix simulation method.

• QasmSimulator methods에서 《density_matrix_gpu》 와 《density_matrix_thrust》에 사용되는 CZ 게이트와 Z 게이트의 버그를 수정하였다.

• Fixes issue where memory requirements of simulation were not being checked on the QasmSimulator when using a non-automatic simulation method.

• GPU 시뮬레이터에 영향을 주었던 메모리 누수를 수정하다.

변경 없음

변경 없음

#### IBM Q 공급자 0.7.2¶

##### 버그 수정¶
• qiskit.provider.ibmq.IBMQBackend.jobs() will now return the correct list of IBMQJob objects when the status kwarg is set to 'RUNNING'. Fixes #523

• The package metadata has been updated to properly reflect the dependency on qiskit-terra >= 0.14.0. This dependency was implicitly added as part of the 0.7.0 release but was not reflected in the package requirements so it was previously possible to install qiskit-ibmq-provider with a version of qiskit-terra which was too old. Fixes #677

### Qiskit 0.19.0¶

#### Terra 0.14.0¶

##### 도입¶

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:

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.

##### 새로운 기능¶
• A new package, python-dateutil, is now required and has been added to the requirements list. It is being used to parse datetime strings received from external providers in BackendProperties objects.

• The marshmallow schema classes in qiskit.providers.models have been removed since they are no longer used by the BackendObjects.

• The output of the to_dict() method for the classes in qiskit.providers.models is no longer in a format for direct JSON serialization. Depending on the content contained in instances of these class there may be numpy arrays and/or complex numbers in the fields of the dict. If you’re JSON serializing the output of the to_dict methods you should ensure your JSON encoder can handle numpy arrays and complex numbers. This includes:

##### 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.

##### 버그 수정¶
• 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¶
• The objects in qiskit.providers.models which were previously constructed using the marshmallow library have been refactored to not depend on marshmallow. This includes:

These should be drop-in replacements without any noticeable change but specifics inherited from marshmallow may not work. Please file issues for any incompatibilities found.

변경 없음

변경 없음

#### Aqua 0.7.0¶

##### 도입¶

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¶

##### 버그 수정¶
• Fixed an issue where nest_asyncio.apply() may raise an exception if there is no asyncio loop due to threading.

### Qiskit 0.18.3¶

변경 없음

#### Aer 0.5.1¶

• 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.

##### 버그 수정¶
• 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.

변경 없음

변경 없음

변경 없음

### Qiskit 0.18.0¶

#### Terra 0.13.0¶

##### 도입¶

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.

##### 새로운 기능¶
• 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

• A new kwarg option, formatted , has been added to qiskit.circuit.QuantumCircuit.qasm() . When set to True 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())

• 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)

• 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()
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:

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': 529, '10': 495}
Measure Qubit-0: {'0': 1024}
Measure Qubit-1: {'0': 508, '1': 516}


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' '11' '11' '01' '01' '01' '11' '01' '01' '01']
Measure Qubit-0: ['1' '1' '1' '1' '1' '1' '1' '1' '1' '1']
Measure Qubit-1: ['0' '1' '0' '0' '1' '1' '0' '0' '1' '1']

• 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: 1 Post-measurement state:
Statevector([0.+0.j, 0.+0.j, 0.+0.j, 1.+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)