def _choose_kak_gate(basis_gates):
"""Choose the first available 2q gate to use in the KAK decomposition."""
kak_gate_names = {
'cx': CXGate(),
'cz': CZGate(),
'iswap': iSwapGate(),
'rxx': RXXGate(pi / 2),
}
kak_gate = None
kak_gates = set(basis_gates or []).intersection(kak_gate_names.keys())
if kak_gates:
kak_gate = kak_gate_names[kak_gates.pop()]
return kak_gate
def twoQubitDecomppser(Gate):
"""
Decomposes a two qubit gate to the Rx,Rz,cz basis
Parameters:
Gate (qiskit Gate object): qiskit quantum gate object "https://qiskit.org/documentation/stubs/qiskit.circuit.Gate.html".
Returns:
QuantumCircuit: Qiskit quantum circuit which contains the decomposition.
"""
twoQubitDecomposer = TwoQubitBasisDecomposer(gate=CZGate(),
basis_fidelity=1.0,
euler_basis="ZXZ")
op = Operator(Gate)
decomposition = twoQubitDecomposer.__call__(op)
return decomposition
def _choose_kak_gate(basis_gates):
"""Choose the first available 2q gate to use in the KAK decomposition."""
kak_gate_names = {
"cx": CXGate(),
"cz": CZGate(),
"iswap": iSwapGate(),
"rxx": RXXGate(pi / 2),
"ecr": ECRGate(),
}
kak_gate = None
kak_gates = set(basis_gates or []).intersection(kak_gate_names.keys())
if kak_gates:
kak_gate = kak_gate_names[kak_gates.pop()]
return kak_gate
def _dag(angles, qubits, back=True):
""" Return a new DAGCircuit with a CZ gate and RZ gates applied (front or back). """
qarg = QuantumRegister(2)
dag = DAGCircuit()
dag.add_qreg(qarg)
cz_node = dag.apply_operation_back(CZGate(),
[qarg[0], qarg[1]])
for angle, qubit in zip(angles, qubits):
if back:
dag.apply_operation_back(RZGate(angle),
[qarg[qubit]], [])
else:
dag.apply_operation_front(RZGate(angle),
[qarg[qubit]], [])
return dag
def _gate_gradient_dict(
gate: Gate) -> List[Tuple[List[complex], List[Instruction]]]:
r"""Given a parameterized gate U(theta) with derivative
dU(theta)/dtheta = sum_ia_iU(theta)V_i.
This function returns a:=[a_0, ...] and V=[V_0, ...]
Suppose U takes multiple parameters, i.e., U(theta^0, ... theta^k).
The returned coefficients and gates are ordered accordingly.
Only parameterized Qiskit gates are supported.
Args:
gate: The gate for which the derivative is being computed.
Returns:
The coefficients and the gates used for the metric computation for each parameter of
the respective gates.
[([a^0], [V^0]) ..., ([a^k], [V^k])]
Raises:
AquaError: If the input gate is controlled by another state but '|1>^{\otimes k}'
TypeError: If the input gate is not a supported parametrized gate.
"""
# pylint: disable=too-many-return-statements
if isinstance(gate, PhaseGate):
# theta
return [([0.5j, -0.5j], [IGate(), CZGate()])]
if isinstance(gate, UGate):
# theta, lambda, phi
return [([-0.5j], [CZGate()]), ([-0.5j], [CZGate()]),
([-0.5j], [CZGate()])]
if isinstance(gate, RXGate):
# theta
return [([-0.5j], [CXGate()])]
if isinstance(gate, RYGate):
# theta
return [([-0.5j], [CYGate()])]
if isinstance(gate, RZGate):
# theta
return [([-0.5j], [CZGate()])]
if isinstance(gate, RXXGate):
# theta
cxx_circ = QuantumCircuit(3)
cxx_circ.cx(0, 1)
cxx_circ.cx(0, 2)
cxx = cxx_circ.to_instruction()
return [([-0.5j], [cxx])]
if isinstance(gate, RYYGate):
# theta
cyy_circ = QuantumCircuit(3)
cyy_circ.cy(0, 1)
cyy_circ.cy(0, 2)
cyy = cyy_circ.to_instruction()
return [([-0.5j], [cyy])]
if isinstance(gate, RZZGate):
# theta
czz_circ = QuantumCircuit(3)
czz_circ.cz(0, 1)
czz_circ.cz(0, 2)
czz = czz_circ.to_instruction()
return [([-0.5j], [czz])]
if isinstance(gate, RZXGate):
# theta
czx_circ = QuantumCircuit(3)
czx_circ.cx(0, 2)
czx_circ.cz(0, 1)
czx = czx_circ.to_instruction()
return [([-0.5j], [czx])]
if isinstance(gate, ControlledGate):
# TODO support arbitrary control states
if gate.ctrl_state != 2**gate.num_ctrl_qubits - 1:
raise AquaError(
'Function only support controlled gates with control state `1` on all control '
'qubits.')
base_coeffs_gates = LinComb._gate_gradient_dict(gate.base_gate)
coeffs_gates = []
# The projectors needed for the gradient of a controlled gate are integrated by a sum
# of gates.
# The following line generates the decomposition gates.
proj_gates_controlled = [[
(-1)**p.count(ZGate()), p
] for p in product([IGate(), ZGate()], repeat=gate.num_ctrl_qubits)
]
for base_coeffs, base_gates in base_coeffs_gates: # loop over parameters
coeffs = []
gates = []
for phase, proj_gates in proj_gates_controlled:
coeffs.extend([
phase * c / (2**gate.num_ctrl_qubits)
for c in base_coeffs
])
for base_gate in base_gates:
controlled_circ = QuantumCircuit(gate.num_ctrl_qubits +
gate.num_qubits)
for i, proj_gate in enumerate(proj_gates):
if isinstance(proj_gate, ZGate):
controlled_circ.cz(0, i + 1)
if not isinstance(base_gate, IGate):
controlled_circ.append(base_gate, [
0,
range(gate.num_ctrl_qubits + 1,
gate.num_ctrl_qubits + gate.num_qubits)
])
gates.append(controlled_circ.to_instruction())
c_g = (coeffs, gates)
coeffs_gates.append(c_g)
return coeffs_gates
raise TypeError('Unrecognized parametrized gate, {}'.format(gate))
_def.append(inst, qargs, cargs)
libr.add('y', _def)
# Ry - Gate
q = QuantumRegister(1, 'q')
_def = QuantumCircuit(q)
theta = Parameter('theta')
rules = [(RZGate(-pi / 2), [q[0]], []), (RXGate(theta), [q[0]], []),
(RZGate(pi / 2), [q[0]], [])]
for inst, qargs, cargs in rules:
_def.append(inst, qargs, cargs)
libr.add('ry', _def)
# CX - Gate
q = QuantumRegister(2, 'q')
_def = QuantumCircuit(q)
rules = [(RZGate(pi / 2), [q[1]], []), (RXGate(pi / 2), [q[1]], []),
(CZGate(), [q[0], q[1]], []), (RXGate(-pi / 2), [q[1]], []),
(RZGate(-pi / 2), [q[1]], [])]
for inst, qargs, cargs in rules:
_def.append(inst, qargs, cargs)
libr.add('cx', _def)
def level_3_pass_manager(
pass_manager_config: PassManagerConfig) -> PassManager:
"""Level 3 pass manager: heavy optimization by noise adaptive qubit mapping and
gate cancellation using commutativity rules and unitary synthesis.
This pass manager applies the user-given initial layout. If none is given, a search
for a perfect layout (i.e. one that satisfies all 2-qubit interactions) is conducted.
If no such layout is found, and device calibration information is available, the
circuit is mapped to the qubits with best readouts and to CX gates with highest fidelity.
The pass manager then transforms the circuit to match the coupling constraints.
It is then unrolled to the basis, and any flipped cx directions are fixed.
Finally, optimizations in the form of commutative gate cancellation, resynthesis
of two-qubit unitary blocks, and redundant reset removal are performed.
Note:
In simulators where ``coupling_map=None``, only the unrolling and
optimization stages are done.
Args:
pass_manager_config: configuration of the pass manager.
Returns:
a level 3 pass manager.
Raises:
TranspilerError: if the passmanager config is invalid.
"""
basis_gates = pass_manager_config.basis_gates
coupling_map = pass_manager_config.coupling_map
initial_layout = pass_manager_config.initial_layout
layout_method = pass_manager_config.layout_method or 'dense'
routing_method = pass_manager_config.routing_method or 'stochastic'
translation_method = pass_manager_config.translation_method or 'translator'
seed_transpiler = pass_manager_config.seed_transpiler
backend_properties = pass_manager_config.backend_properties
# 1. Unroll to 1q or 2q gates
_unroll3q = Unroll3qOrMore()
# 2. Layout on good qubits if calibration info available, otherwise on dense links
_given_layout = SetLayout(initial_layout)
def _choose_layout_condition(property_set):
return not property_set['layout']
_choose_layout_1 = CSPLayout(coupling_map, call_limit=10000, time_limit=60)
if layout_method == 'trivial':
_choose_layout_2 = TrivialLayout(coupling_map)
elif layout_method == 'dense':
_choose_layout_2 = DenseLayout(coupling_map, backend_properties)
elif layout_method == 'noise_adaptive':
_choose_layout_2 = NoiseAdaptiveLayout(backend_properties)
elif layout_method == 'sabre':
_choose_layout_2 = SabreLayout(coupling_map,
max_iterations=4,
seed=seed_transpiler)
else:
raise TranspilerError("Invalid layout method %s." % layout_method)
# 3. Extend dag/layout with ancillas using the full coupling map
_embed = [
FullAncillaAllocation(coupling_map),
EnlargeWithAncilla(),
ApplyLayout()
]
# 4. Swap to fit the coupling map
_swap_check = CheckMap(coupling_map)
def _swap_condition(property_set):
return not property_set['is_swap_mapped']
_swap = [BarrierBeforeFinalMeasurements()]
if routing_method == 'basic':
_swap += [BasicSwap(coupling_map)]
elif routing_method == 'stochastic':
_swap += [
StochasticSwap(coupling_map, trials=200, seed=seed_transpiler)
]
elif routing_method == 'lookahead':
_swap += [LookaheadSwap(coupling_map, search_depth=5, search_width=6)]
elif routing_method == 'sabre':
_swap += [
SabreSwap(coupling_map, heuristic='decay', seed=seed_transpiler)
]
else:
raise TranspilerError("Invalid routing method %s." % routing_method)
# 5. Unroll to the basis
if translation_method == 'unroller':
_unroll = [Unroller(basis_gates)]
elif translation_method == 'translator':
from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel
_unroll = [
UnrollCustomDefinitions(sel, basis_gates),
BasisTranslator(sel, basis_gates)
]
else:
raise TranspilerError("Invalid translation method %s." %
translation_method)
# 6. Fix any CX direction mismatch
_direction_check = [CheckCXDirection(coupling_map)]
def _direction_condition(property_set):
return not property_set['is_direction_mapped']
_direction = [CXDirection(coupling_map)]
# 8. Optimize iteratively until no more change in depth. Removes useless gates
# after reset and before measure, commutes gates and optimizes continguous blocks.
_depth_check = [Depth(), FixedPoint('depth')]
def _opt_control(property_set):
return not property_set['depth_fixed_point']
_reset = [RemoveResetInZeroState()]
_meas = [OptimizeSwapBeforeMeasure(), RemoveDiagonalGatesBeforeMeasure()]
# Choose the first available 2q gate to use in the KAK decomposition.
from qiskit.circuit.library.standard_gates import iSwapGate, CXGate, CZGate, RXXGate
kak_gate_names = {
'iswap': iSwapGate(),
'cx': CXGate(),
'cz': CZGate(),
'rxx': RXXGate(math.pi / 2)
}
kak_gate = None
kak_gates = set(basis_gates or []).intersection(kak_gate_names.keys())
if kak_gates:
kak_gate = kak_gate_names[kak_gates.pop()]
_opt = [
Collect2qBlocks(),
ConsolidateBlocks(kak_basis_gate=kak_gate),
Optimize1qGates(basis_gates),
CommutativeCancellation()
]
# Build pass manager
pm3 = PassManager()
pm3.append(_unroll3q)
if coupling_map:
pm3.append(_given_layout)
pm3.append(_choose_layout_1, condition=_choose_layout_condition)
pm3.append(_choose_layout_2, condition=_choose_layout_condition)
pm3.append(_embed)
pm3.append(_reset + _meas)
pm3.append(_swap_check)
pm3.append(_swap, condition=_swap_condition)
pm3.append(_depth_check + _opt + _unroll, do_while=_opt_control)
if coupling_map and not coupling_map.is_symmetric:
pm3.append(_direction_check)
pm3.append(_direction, condition=_direction_condition)
pm3.append(_reset)
return pm3
from qiskit.quantum_info.synthesis.two_qubit_decompose import TwoQubitBasisDecomposer
from qiskit.circuit.parameter import Parameter
from qiskit.circuit.library.standard_gates import (
iSwapGate,
CXGate,
CZGate,
RXXGate,
RZXGate,
ECRGate,
)
from qiskit.transpiler.passes.synthesis import plugin
from qiskit.providers.models import BackendProperties
KAK_GATE_NAMES = {
"cx": CXGate(),
"cz": CZGate(),
"iswap": iSwapGate(),
"rxx": RXXGate(pi / 2),
"ecr": ECRGate(),
"rzx": RZXGate(pi / 4), # typically pi/6 is also available
}
def _choose_kak_gate(basis_gates):
"""Choose the first available 2q gate to use in the KAK decomposition."""
kak_gate = None
kak_gates = set(basis_gates or []).intersection(KAK_GATE_NAMES.keys())
if kak_gates:
kak_gate = KAK_GATE_NAMES[kak_gates.pop()]
return kak_gate
def _standard_gate_instruction(instruction, ignore_phase=True):
"""Temporary function to create Instruction objects from a json string,
which is necessary for creating a new QuantumError object from deprecated
json-based input. Note that the type of returned object is different from
the deprecated standard_gate_instruction.
TODO: to be removed after deprecation period.
Args:
instruction (dict): A qobj instruction.
ignore_phase (bool): Ignore global phase on unitary matrix in
comparison to canonical unitary.
Returns:
list: a list of (instructions, qubits) equivalent to in input instruction.
"""
gate = {
"id": IGate(),
"x": XGate(),
"y": YGate(),
"z": ZGate(),
"h": HGate(),
"s": SGate(),
"sdg": SdgGate(),
"t": TGate(),
"tdg": TdgGate(),
"cx": CXGate(),
"cz": CZGate(),
"swap": SwapGate()
}
name = instruction.get("name", None)
qubits = instruction["qubits"]
if name in gate:
return [(gate[name], qubits)]
if name not in ["mat", "unitary", "kraus"]:
return [instruction]
params = instruction["params"]
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
category=DeprecationWarning,
module="qiskit.providers.aer.noise.errors.errorutils")
# Check for single-qubit reset Kraus
if name == "kraus":
if len(qubits) == 1:
superop = SuperOp(Kraus(params))
# Check if reset to |0>
reset0 = reset_superop(1)
if superop == reset0:
return [(Reset(), [0])]
# Check if reset to |1>
reset1 = reset0.compose(Operator(standard_gate_unitary('x')))
if superop == reset1:
return [(Reset(), [0]), (XGate(), [0])]
return [instruction]
# Check single qubit gates
mat = params[0]
if len(qubits) == 1:
# Check clifford gates
for j in range(24):
if matrix_equal(
mat,
single_qubit_clifford_matrix(j),
ignore_phase=ignore_phase):
return [(gate, [0]) for gate in _CLIFFORD_GATES[j]]
# Check t gates
for name in ["t", "tdg"]:
if matrix_equal(
mat,
standard_gate_unitary(name),
ignore_phase=ignore_phase):
return [(gate[name], qubits)]
# TODO: u1,u2,u3 decomposition
# Check two qubit gates
if len(qubits) == 2:
for name in ["cx", "cz", "swap"]:
if matrix_equal(
mat,
standard_gate_unitary(name),
ignore_phase=ignore_phase):
return [(gate[name], qubits)]
# Check reversed CX
if matrix_equal(
mat,
standard_gate_unitary("cx_10"),
ignore_phase=ignore_phase):
return [(CXGate(), [qubits[1], qubits[0]])]
# Check 2-qubit Pauli's
paulis = ["id", "x", "y", "z"]
for pauli0 in paulis:
for pauli1 in paulis:
pmat = np.kron(
standard_gate_unitary(pauli1),
standard_gate_unitary(pauli0))
if matrix_equal(mat, pmat, ignore_phase=ignore_phase):
if pauli0 == "id":
return [(gate[pauli1], [qubits[1]])]
elif pauli1 == "id":
return [(gate[pauli0], [qubits[0]])]
else:
return [(gate[pauli0], [qubits[0]]), (gate[pauli1], [qubits[1]])]
# Check three qubit toffoli
if len(qubits) == 3:
if matrix_equal(
mat,
standard_gate_unitary("ccx_012"),
ignore_phase=ignore_phase):
return [(CCXGate(), qubits)]
if matrix_equal(
mat,
standard_gate_unitary("ccx_021"),
ignore_phase=ignore_phase):
return [(CCXGate(), [qubits[0], qubits[2], qubits[1]])]
if matrix_equal(
mat,
standard_gate_unitary("ccx_120"),
ignore_phase=ignore_phase):
return [(CCXGate(), [qubits[1], qubits[2], qubits[0]])]
# Else return input in
return [instruction]
