def _define(self):
definition = []
qr = QuantumRegister(self.num_qubits)
oracle_qr = [qr[i] for i in self.oracle_qubits]
# Prepare the auxiliary qubit into the Hadamard minus state.
definition.append((HGate(), [qr[-1]], []))
definition.append((ZGate(), [qr[-1]], []))
# Add the boolean oracle whose behavior is
# determined by the auxiliary qubit.
definition.append((BooleanOracleGate(self.classical_boolean_oracle),
oracle_qr + [qr[-1]], []))
# Add the inverse of the quantum algorithm.
definition.append((self.quantum_algorithm.inverse(), qr[:-1], []))
# Add the 'inversion around the mean' operator as a
# special boolean oracle that behaves as a phase oracle
# because of how was set the auxiliary qubit.
definition.append(
(BooleanOracleGate([1] + [0] * (2**(self.num_qubits - 1) - 1)),
qr[:], []))
# Add the quantum algorithm.
definition.append((self.quantum_algorithm, qr[:-1], []))
# Revert the auxiliary qubit to zero.
definition.append((ZGate(), [qr[-1]], []))
definition.append((HGate(), [qr[-1]], []))
self.definition = definition
def _rzx_dag(parameter):
_rzx_dag = DAGCircuit()
qr = QuantumRegister(2)
_rzx_dag.add_qreg(qr)
_rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
_rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
_rzx_dag.apply_operation_back(RZXGate(parameter), [qr[1], qr[0]], [])
_rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
_rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
return _rzx_dag
def _reverse_echo_rzx_dag(theta):
reverse_rzx_dag = DAGCircuit()
qr = QuantumRegister(2)
reverse_rzx_dag.add_qreg(qr)
reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
reverse_rzx_dag.apply_operation_back(RZXGate(theta / 2),
[qr[1], qr[0]], [])
reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], [])
reverse_rzx_dag.apply_operation_back(RZXGate(-theta / 2),
[qr[1], qr[0]], [])
reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], [])
reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
return reverse_rzx_dag
def test_clifford_circuit_noise(self, method, device):
"""Test simulation with mixed Clifford quantum errors in circuit."""
backend = self.backend(method=method, device=device)
shots = 1000
error1 = noise.QuantumError([
([(IGate(), [0])], 0.8),
([(Reset(), [0])], 0.1),
([(HGate(), [0])], 0.1)])
error2 = noise.QuantumError([
([(IGate(), [0])], 0.75),
([(Reset(), [0])], 0.1),
([(Reset(), [1])], 0.1),
([(Reset(), [0]), (Reset(), [1])], 0.05)])
qc = QuantumCircuit(2)
qc.h(0)
qc.append(error1, [0])
qc.cx(0, 1)
qc.append(error2, [0, 1])
target_probs = qi.DensityMatrix(qc).probabilities_dict()
# Add measurement
qc.measure_all()
result = backend.run(qc, shots=shots).result()
self.assertSuccess(result)
probs = {key: val / shots for key, val in result.get_counts(0).items()}
self.assertDictAlmostEqual(target_probs, probs, delta=0.1)
def setUp(self):
super().setUp()
self.ops = {
'X': XGate(),
'Y': YGate(),
'Z': ZGate(),
'H': HGate(),
'S': SGate()
}
def from_label(cls, label):
"""Return a tensor product of single-qubit operators.
Args:
label (string): single-qubit operator string.
Returns:
Operator: The N-qubit operator.
Raises:
QiskitError: if the label contains invalid characters, or the
length of the label is larger than an explicitly
specified num_qubits.
Additional Information:
The labels correspond to the single-qubit matrices:
'I': [[1, 0], [0, 1]]
'X': [[0, 1], [1, 0]]
'Y': [[0, -1j], [1j, 0]]
'Z': [[1, 0], [0, -1]]
'H': [[1, 1], [1, -1]] / sqrt(2)
'S': [[1, 0], [0 , 1j]]
'T': [[1, 0], [0, (1+1j) / sqrt(2)]]
'0': [[1, 0], [0, 0]]
'1': [[0, 0], [0, 1]]
'+': [[0.5, 0.5], [0.5 , 0.5]]
'-': [[0.5, -0.5], [-0.5 , 0.5]]
'r': [[0.5, -0.5j], [0.5j , 0.5]]
'l': [[0.5, 0.5j], [-0.5j , 0.5]]
"""
# Check label is valid
label_mats = {
'I': IGate().to_matrix(),
'X': XGate().to_matrix(),
'Y': YGate().to_matrix(),
'Z': ZGate().to_matrix(),
'H': HGate().to_matrix(),
'S': SGate().to_matrix(),
'T': TGate().to_matrix(),
'0': np.array([[1, 0], [0, 0]], dtype=complex),
'1': np.array([[0, 0], [0, 1]], dtype=complex),
'+': np.array([[0.5, 0.5], [0.5, 0.5]], dtype=complex),
'-': np.array([[0.5, -0.5], [-0.5, 0.5]], dtype=complex),
'r': np.array([[0.5, -0.5j], [0.5j, 0.5]], dtype=complex),
'l': np.array([[0.5, 0.5j], [-0.5j, 0.5]], dtype=complex),
}
if re.match(r'^[IXYZHST01rl\-+]+$', label) is None:
raise QiskitError('Label contains invalid characters.')
# Initialize an identity matrix and apply each gate
num_qubits = len(label)
op = Operator(np.eye(2 ** num_qubits, dtype=complex))
for qubit, char in enumerate(reversed(label)):
if char != 'I':
op = op.compose(label_mats[char], qargs=[qubit])
return op
def from_label(label):
"""Return a tensor product of single-qubit Clifford gates.
Args:
label (string): single-qubit operator string.
Returns:
Clifford: The N-qubit Clifford operator.
Raises:
QiskitError: if the label contains invalid characters.
Additional Information:
The labels correspond to the single-qubit Cliffords are
* - Label
- Stabilizer
- Destabilizer
* - ``"I"``
- +Z
- +X
* - ``"X"``
- -Z
- +X
* - ``"Y"``
- -Z
- -X
* - ``"Z"``
- +Z
- -X
* - ``"H"``
- +X
- +Z
* - ``"S"``
- +Z
- +Y
"""
# Check label is valid
label_gates = {
'I': IGate(),
'X': XGate(),
'Y': YGate(),
'Z': ZGate(),
'H': HGate(),
'S': SGate()
}
if re.match(r'^[IXYZHS\-+]+$', label) is None:
raise QiskitError('Label contains invalid characters.')
# Initialize an identity matrix and apply each gate
num_qubits = len(label)
op = Clifford(np.eye(2 * num_qubits, dtype=np.bool))
for qubit, char in enumerate(reversed(label)):
_append_circuit(op, label_gates[char], qargs=[qubit])
return op
def __init__(self, coupling_map, target=None):
"""GateDirection pass.
Args:
coupling_map (CouplingMap): Directed graph represented a coupling map.
target (Target): The backend target to use for this pass. If this is specified
it will be used instead of the coupling map
"""
super().__init__()
self.coupling_map = coupling_map
self.target = target
# Create the replacement dag and associated register.
self._cx_dag = DAGCircuit()
qr = QuantumRegister(2)
self._cx_dag.add_qreg(qr)
self._cx_dag.apply_operation_back(HGate(), [qr[0]], [])
self._cx_dag.apply_operation_back(HGate(), [qr[1]], [])
self._cx_dag.apply_operation_back(CXGate(), [qr[1], qr[0]], [])
self._cx_dag.apply_operation_back(HGate(), [qr[0]], [])
self._cx_dag.apply_operation_back(HGate(), [qr[1]], [])
self._ecr_dag = DAGCircuit()
qr = QuantumRegister(2)
self._ecr_dag.add_qreg(qr)
self._ecr_dag.apply_operation_back(RYGate(-pi / 2), [qr[0]], [])
self._ecr_dag.apply_operation_back(RYGate(pi / 2), [qr[1]], [])
self._ecr_dag.apply_operation_back(ECRGate(), [qr[1], qr[0]], [])
self._ecr_dag.apply_operation_back(HGate(), [qr[0]], [])
self._ecr_dag.apply_operation_back(HGate(), [qr[1]], [])
def __init__(self, coupling_map):
"""GateDirection pass.
Args:
coupling_map (CouplingMap): Directed graph represented a coupling map.
"""
super().__init__()
self.coupling_map = coupling_map
# Create the replacement dag and associated register.
self._cx_dag = DAGCircuit()
qr = QuantumRegister(2)
self._cx_dag.add_qreg(qr)
self._cx_dag.apply_operation_back(HGate(), [qr[0]], [])
self._cx_dag.apply_operation_back(HGate(), [qr[1]], [])
self._cx_dag.apply_operation_back(CXGate(), [qr[1], qr[0]], [])
self._cx_dag.apply_operation_back(HGate(), [qr[0]], [])
self._cx_dag.apply_operation_back(HGate(), [qr[1]], [])
self._ecr_dag = DAGCircuit()
qr = QuantumRegister(2)
self._ecr_dag.add_qreg(qr)
self._ecr_dag.apply_operation_back(RYGate(-pi / 2), [qr[0]], [])
self._ecr_dag.apply_operation_back(RYGate(pi / 2), [qr[1]], [])
self._ecr_dag.apply_operation_back(ECRGate(), [qr[1], qr[0]], [])
self._ecr_dag.apply_operation_back(HGate(), [qr[0]], [])
self._ecr_dag.apply_operation_back(HGate(), [qr[1]], [])
def _reverse_echo_rzx_dag(theta):
"""Return the following circuit
.. parsed-literal::
┌───┐┌───────────────┐ ┌────────────────┐┌───┐
q_0: ┤ H ├┤1 ├─────┤1 ├┤ H ├─────
├───┤│ Rzx(theta/2) │┌───┐│ Rzx(-theta/2) │├───┤┌───┐
q_1: ┤ H ├┤0 ├┤ X ├┤0 ├┤ X ├┤ H ├
└───┘└───────────────┘└───┘└────────────────┘└───┘└───┘
"""
reverse_rzx_dag = DAGCircuit()
qr = QuantumRegister(2)
reverse_rzx_dag.add_qreg(qr)
reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
reverse_rzx_dag.apply_operation_back(RZXGate(theta / 2), [qr[1], qr[0]], [])
reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], [])
reverse_rzx_dag.apply_operation_back(RZXGate(-theta / 2), [qr[1], qr[0]], [])
reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], [])
reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
return reverse_rzx_dag
def _define(self):
definition = []
qr = QuantumRegister(self.num_qubits)
for i in reversed(range(self.num_qubits)):
definition.append((HGate(), [qr[i]], []))
for j in range(i):
definition.append(
(CU1Gate(np.pi / 2.0**(i - j)), [qr[j], qr[i]], []))
if self.do_swaps:
for i in range(self.num_qubits // 2):
definition.append(
(SwapGate(), [qr[i], qr[self.num_qubits - 1 - i]], []))
self.definition = definition
def _define(self):
definition = []
# qr[:self.num_phase_qubits]: phase qubits
# qr[self.num_phase_qubits:]: state qubits
qr = QuantumRegister(self.num_qubits)
# Loop over the phase qubits.
for i in range(self.num_phase_qubits):
definition.append((HGate(), [qr[i]], []))
for _ in range(2**i):
definition.append(
(self.unitary_gate.control(num_ctrl_qubits=1),
[qr[i]] + qr[self.num_phase_qubits:], []))
definition.append((QFTGate(self.num_phase_qubits).inverse(),
qr[:self.num_phase_qubits], []))
self.definition = definition
def __init__(
self,
feature_dimension: Optional[int] = None,
reps: int = 2,
entanglement: Union[str, List[List[int]], Callable[[int], List[int]]] = "full",
alpha: float = 2.0,
paulis: Optional[List[str]] = None,
data_map_func: Optional[Callable[[np.ndarray], float]] = None,
parameter_prefix: str = "x",
insert_barriers: bool = False,
name: str = "PauliFeatureMap",
) -> None:
"""Create a new Pauli expansion circuit.
Args:
feature_dimension: Number of qubits in the circuit.
reps: The number of repeated circuits.
entanglement: Specifies the entanglement structure. Refer to
:class:`~qiskit.circuit.library.NLocal` for detail.
alpha: The Pauli rotation factor, multiplicative to the pauli rotations
paulis: A list of strings for to-be-used paulis. If None are provided, ``['Z', 'ZZ']``
will be used.
data_map_func: A mapping function for data x which can be supplied to override the
default mapping from :meth:`self_product`.
parameter_prefix: The prefix used if default parameters are generated.
insert_barriers: If True, barriers are inserted in between the evolution instructions
and hadamard layers.
"""
super().__init__(
num_qubits=feature_dimension,
reps=reps,
rotation_blocks=HGate(),
entanglement=entanglement,
parameter_prefix=parameter_prefix,
insert_barriers=insert_barriers,
skip_final_rotation_layer=True,
name=name,
)
self._data_map_func = data_map_func or self_product
self._paulis = paulis or ["Z", "ZZ"]
self._alpha = alpha
def get_subcircuit_instance(subcircuit_idx, subcircuit, combinations):
circ_dict = {}
for combination_ctr, combination in enumerate(combinations):
# print('combination %d/%d :'%(combination_ctr,len(combinations)),combination)
subcircuit_dag = circuit_to_dag(subcircuit)
inits, meas = combination
for i, x in enumerate(inits):
q = subcircuit.qubits[i]
if x == 'zero':
continue
elif x == 'one':
subcircuit_dag.apply_operation_front(op=XGate(),
qargs=[q],
cargs=[])
elif x == 'plus':
subcircuit_dag.apply_operation_front(op=HGate(),
qargs=[q],
cargs=[])
elif x == 'minus':
subcircuit_dag.apply_operation_front(op=HGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_front(op=XGate(),
qargs=[q],
cargs=[])
elif x == 'plusI':
subcircuit_dag.apply_operation_front(op=SGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_front(op=HGate(),
qargs=[q],
cargs=[])
elif x == 'minusI':
subcircuit_dag.apply_operation_front(op=SGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_front(op=HGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_front(op=XGate(),
qargs=[q],
cargs=[])
else:
raise Exception('Illegal initialization : ', x)
for i, x in enumerate(meas):
q = subcircuit.qubits[i]
if x == 'I' or x == 'comp':
continue
elif x == 'X':
subcircuit_dag.apply_operation_back(op=HGate(),
qargs=[q],
cargs=[])
elif x == 'Y':
subcircuit_dag.apply_operation_back(op=SdgGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_back(op=HGate(),
qargs=[q],
cargs=[])
else:
raise Exception('Illegal measurement basis:', x)
subcircuit_inst = dag_to_circuit(subcircuit_dag)
# NOTE: Adjust subcircuit shots here
num_shots = max(8192, int(2**subcircuit_inst.num_qubits))
num_shots = min(8192 * 10, num_shots)
circ_dict[(subcircuit_idx, tuple(inits), tuple(meas))] = {
'circuit': subcircuit_inst,
'shots': num_shots
}
return circ_dict
eq_lib = EquivalenceLibrary()
theta = Parameter('theta')
phi = Parameter('phi')
lamda = Parameter('lamda')
u3 = U3Gate(theta, phi, lamda)
u2 = U2Gate(theta, phi)
u1 = U1Gate(theta)
ccx = CCXGate()
q = QuantumRegister(1, 'q')
equiv_u3 = QuantumCircuit(q)
equiv_u3.append(RZGate(phi+(pi/2)), [q[0]], [])
equiv_u3.append(HGate(),[q[0]], [] )
equiv_u3.append(RZGate(theta),[q[0]], [])
equiv_u3.append(HGate(), [q[0]], [])
equiv_u3.append(RZGate(lamda-(pi/2)),[q[0]], 0)
eq_lib.add_equivalence(u3, equiv_u3)
q = QuantumRegister(1, 'q')
equiv_u2 = QuantumCircuit(q)
equiv_u2.append(RZGate(theta+(pi/2)), [q[0]], [])
equiv_u2.append(HGate(),[q[0]], [] )
equiv_u2.append(RZGate(pi/2),[q[0]], [])
equiv_u2.append(HGate(), [q[0]], [])
equiv_u2.append(RZGate(phi-(pi/2)),[q[0]], 0)
eq_lib.add_equivalence(u2, equiv_u2)
def func(op, qubits):
if tuple(qubits) == (1, ):
return HGate()
return None
def func(op, qubits):
# return H for qubit 1 and None for the other qubits
if tuple(qubits) == (1, ):
return HGate()
return None
def modify_subcircuit_instance(subcircuit, init, meas):
"""
Modify the different init, meas for a given subcircuit
Returns:
Modified subcircuit_instance
List of mutated measurements
"""
subcircuit_dag = circuit_to_dag(subcircuit)
subcircuit_instance_dag = copy.deepcopy(subcircuit_dag)
for i, x in enumerate(init):
q = subcircuit.qubits[i]
if x == "zero":
continue
elif x == "one":
subcircuit_instance_dag.apply_operation_front(
op=XGate(), qargs=[q], cargs=[]
)
elif x == "plus":
subcircuit_instance_dag.apply_operation_front(
op=HGate(), qargs=[q], cargs=[]
)
elif x == "minus":
subcircuit_instance_dag.apply_operation_front(
op=HGate(), qargs=[q], cargs=[]
)
subcircuit_instance_dag.apply_operation_front(
op=XGate(), qargs=[q], cargs=[]
)
elif x == "plusI":
subcircuit_instance_dag.apply_operation_front(
op=SGate(), qargs=[q], cargs=[]
)
subcircuit_instance_dag.apply_operation_front(
op=HGate(), qargs=[q], cargs=[]
)
elif x == "minusI":
subcircuit_instance_dag.apply_operation_front(
op=SGate(), qargs=[q], cargs=[]
)
subcircuit_instance_dag.apply_operation_front(
op=HGate(), qargs=[q], cargs=[]
)
subcircuit_instance_dag.apply_operation_front(
op=XGate(), qargs=[q], cargs=[]
)
else:
raise Exception("Illegal initialization :", x)
for i, x in enumerate(meas):
q = subcircuit.qubits[i]
if x == "I" or x == "comp":
continue
elif x == "X":
subcircuit_instance_dag.apply_operation_back(
op=HGate(), qargs=[q], cargs=[]
)
elif x == "Y":
subcircuit_instance_dag.apply_operation_back(
op=SdgGate(), qargs=[q], cargs=[]
)
subcircuit_instance_dag.apply_operation_back(
op=HGate(), qargs=[q], cargs=[]
)
else:
raise Exception("Illegal measurement basis:", x)
subcircuit_instance_circuit = dag_to_circuit(subcircuit_instance_dag)
return subcircuit_instance_circuit
def get_one_subcircuit_instances(subcircuit, combinations):
'''
Modify the different init, meas for a given subcircuit
Returns:
subcircuit_instances[subcircuit_instance_idx] = circuit, init, meas, shots
subcircuit_instances_idx[init,meas] = subcircuit_instance_idx
'''
subcircuit_instances = {}
subcircuit_instances_idx = {}
for combination_ctr, combination in enumerate(combinations):
# print('combination %d/%d :'%(combination_ctr+1,len(combinations)),combination)
subcircuit_dag = circuit_to_dag(subcircuit)
inits, meas = combination
for i, x in enumerate(inits):
q = subcircuit.qubits[i]
if x == 'zero':
continue
elif x == 'one':
subcircuit_dag.apply_operation_front(op=XGate(),
qargs=[q],
cargs=[])
elif x == 'plus':
subcircuit_dag.apply_operation_front(op=HGate(),
qargs=[q],
cargs=[])
elif x == 'minus':
subcircuit_dag.apply_operation_front(op=HGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_front(op=XGate(),
qargs=[q],
cargs=[])
elif x == 'plusI':
subcircuit_dag.apply_operation_front(op=SGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_front(op=HGate(),
qargs=[q],
cargs=[])
elif x == 'minusI':
subcircuit_dag.apply_operation_front(op=SGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_front(op=HGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_front(op=XGate(),
qargs=[q],
cargs=[])
else:
raise Exception('Illegal initialization : ', x)
for i, x in enumerate(meas):
q = subcircuit.qubits[i]
if x == 'I' or x == 'comp':
continue
elif x == 'X':
subcircuit_dag.apply_operation_back(op=HGate(),
qargs=[q],
cargs=[])
elif x == 'Y':
subcircuit_dag.apply_operation_back(op=SdgGate(),
qargs=[q],
cargs=[])
subcircuit_dag.apply_operation_back(op=HGate(),
qargs=[q],
cargs=[])
else:
raise Exception('Illegal measurement basis:', x)
subcircuit_inst = dag_to_circuit(subcircuit_dag)
num_shots = max(8192, int(2**subcircuit_inst.num_qubits))
num_shots = min(8192 * 10, num_shots)
mutated_meas = mutate_measurement_basis(meas)
for idx, meas in enumerate(mutated_meas):
subcircuit_instance_idx = len(subcircuit_instances)
if idx == 0:
parent_subcircuit_instance_idx = subcircuit_instance_idx
shots = num_shots
else:
shots = 0
subcircuit_instances[subcircuit_instance_idx] = {
'circuit': subcircuit_inst,
'init': tuple(inits),
'meas': tuple(meas),
'shots': shots,
'parent': parent_subcircuit_instance_idx
}
subcircuit_instances_idx[(tuple(inits),
tuple(meas))] = subcircuit_instance_idx
return subcircuit_instances, subcircuit_instances_idx
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]
(
'x', ),
('y', ),
('s', 'x'),
('sdg', 'x')
]
return labels[j]
_CLIFFORD_GATES = [
(IGate(), ),
(SGate(), ),
(SdgGate(), ),
(ZGate(), ),
# u2 gates
(HGate(), ),
(HGate(), ZGate()),
(ZGate(), HGate()),
(HGate(), SGate()),
(SGate(), HGate()),
(HGate(), SdgGate()),
(SdgGate(), HGate()),
(SGate(), HGate(), SGate()),
(SdgGate(), HGate(), SGate()),
(ZGate(), HGate(), SGate()),
(SGate(), HGate(), SdgGate()),
(SdgGate(), HGate(), SdgGate()),
(ZGate(), HGate(), SdgGate()),
(SGate(), HGate(), ZGate()),
(SdgGate(), HGate(), ZGate()),
(ZGate(), HGate(), ZGate()),