def test_if_else_invalid_params_setter(self):
"""Verify we catch invalid param settings for IfElseOp."""
condition = (Clbit(), True)
true_body = QuantumCircuit(3, 1)
false_body = QuantumCircuit(3, 1)
op = IfElseOp(condition, true_body, false_body)
with self.assertRaisesRegex(
CircuitError, r"true_body parameter of type QuantumCircuit"):
op.params = [XGate(), None]
with self.assertRaisesRegex(
CircuitError, r"false_body parameter of type QuantumCircuit"):
op.params = [true_body, XGate()]
bad_body = QuantumCircuit(4, 2)
with self.assertRaisesRegex(
CircuitError,
r"num_clbits different than that of the IfElseOp"):
op.params = [true_body, bad_body]
with self.assertRaisesRegex(
CircuitError,
r"num_clbits different than that of the IfElseOp"):
op.params = [bad_body, false_body]
with self.assertRaisesRegex(
CircuitError,
r"num_clbits different than that of the IfElseOp"):
op.params = [bad_body, bad_body]
def test_if_else_invalid_instantiation(self):
"""Verify we catch invalid instantiations of IfElseOp."""
condition = (Clbit(), True)
true_body = QuantumCircuit(3, 1)
false_body = QuantumCircuit(3, 1)
with self.assertRaisesRegex(
CircuitError, r"A classical condition should be a 2-tuple"):
_ = IfElseOp(1, true_body, false_body)
with self.assertRaisesRegex(
CircuitError, r"A classical condition should be a 2-tuple"):
_ = IfElseOp((1, 2), true_body, false_body)
with self.assertRaisesRegex(
CircuitError, r"true_body parameter of type QuantumCircuit"):
_ = IfElseOp(condition, XGate())
with self.assertRaisesRegex(
CircuitError, r"false_body parameter of type QuantumCircuit"):
_ = IfElseOp(condition, true_body, XGate())
bad_body = QuantumCircuit(4, 2)
with self.assertRaisesRegex(
CircuitError,
r"num_clbits different than that of the IfElseOp"):
_ = IfElseOp(condition, true_body, bad_body)
def test_inverse_x(self, num_ctrl_qubits):
"""Test inverting the controlled X gate."""
cnx = XGate().control(num_ctrl_qubits)
inv_cnx = cnx.inverse()
result = Operator(cnx).compose(Operator(inv_cnx))
np.testing.assert_array_almost_equal(result.data,
np.identity(result.dim[0]))
def test_mcmt_label(self, mcmt_class):
"""Test MCMT label remains functional but is deprecated."""
custom_label = "abc"
with self.subTest(msg="init with label and get"):
with self.assertWarns(DeprecationWarning):
mcmt = mcmt_class(
XGate(), num_ctrl_qubits=1, num_target_qubits=1, label=custom_label
)
with self.assertWarns(DeprecationWarning):
self.assertEqual(mcmt.label, custom_label)
with self.subTest(msg="label set and get"):
mcmt = mcmt_class(XGate(), num_ctrl_qubits=1, num_target_qubits=1)
with self.assertWarns(DeprecationWarning):
mcmt.label = custom_label
with self.assertWarns(DeprecationWarning):
self.assertEqual(mcmt.label, custom_label)
with self.subTest(msg="control gate label"):
mcmt = mcmt_class(XGate(), num_ctrl_qubits=1, num_target_qubits=1)
c_mcmt = mcmt.control()
with self.assertWarns(DeprecationWarning):
c_mcmt = mcmt.control(label=custom_label)
with self.assertWarns(DeprecationWarning):
self.assertEqual(c_mcmt.label, custom_label)
def test_dd_with_calibrations_with_parameters(self, param_value):
"""Check that calibrations in a circuit with parameters work fine."""
circ = QuantumCircuit(2)
circ.x(0)
circ.cx(0, 1)
circ.rx(param_value, 1)
rx_duration = int(param_value * 1000)
with pulse.build() as rx:
pulse.play(pulse.Gaussian(rx_duration, 0.1, rx_duration // 4),
pulse.DriveChannel(1))
circ.add_calibration("rx", (1, ), rx, params=[param_value])
durations = InstructionDurations([("x", None, 100), ("cx", None, 300)])
dd_sequence = [XGate(), XGate()]
pm = PassManager([
ALAPScheduleAnalysis(durations),
PadDynamicalDecoupling(durations, dd_sequence)
])
self.assertEqual(pm.run(circ).duration, rx_duration + 100 + 300)
def test_different_gate_types(self):
"""Test the different supported input types for the target gate."""
x_circ = QuantumCircuit(1)
x_circ.x(0)
for input_gate in [x_circ, QuantumCircuit.cx, QuantumCircuit.x, "cx", "x", CXGate()]:
with self.subTest(input_gate=input_gate):
mcmt = MCMT(input_gate, 2, 2)
if isinstance(input_gate, QuantumCircuit):
self.assertEqual(mcmt.gate.definition[0][0], XGate())
self.assertEqual(len(mcmt.gate.definition), 1)
else:
self.assertEqual(mcmt.gate, XGate())
def test_standard_gate_with_label(self):
"""Test a standard gate with a label."""
qc = QuantumCircuit(1)
gate = XGate()
gate.label = "My special X gate"
qc.append(gate, [0])
qpy_file = io.BytesIO()
dump(qc, qpy_file)
qpy_file.seek(0)
new_circ = load(qpy_file)[0]
self.assertEqual(qc, new_circ)
self.assertEqual([x[0].label for x in qc.data], [x[0].label for x in new_circ.data])
def test_caching_different_qubit_sets(self):
"""Check that hashing same commutativity results over different qubit sets works as expected."""
comm_checker = CommutationChecker()
# All the following should be cached in the same way
# though each relation gets cached twice: (A, B) and (B, A)
comm_checker.commute(XGate(), [0], [], CXGate(), [0, 1], [])
comm_checker.commute(XGate(), [10], [], CXGate(), [10, 20], [])
comm_checker.commute(XGate(), [10], [], CXGate(), [10, 5], [])
comm_checker.commute(XGate(), [5], [], CXGate(), [5, 7], [])
self.assertEqual(len(comm_checker.cache), 2)
def test_circuit_with_conditional_with_label(self):
"""Test that instructions with conditions are correctly serialized."""
qc = QuantumCircuit(1, 1)
gate = XGate(label="My conditional x gate")
gate.c_if(qc.cregs[0], 1)
qc.append(gate, [0])
qpy_file = io.BytesIO()
dump(qc, qpy_file)
qpy_file.seek(0)
new_circ = load(qpy_file)[0]
self.assertEqual(qc, new_circ)
self.assertEqual([x[0].label for x in qc.data], [x[0].label for x in new_circ.data])
def test_insert_dd_ghz_one_qubit(self):
"""Test DD gates are inserted on only one qubit.
┌───┐ ┌────────────────┐ ┌───┐ »
q_0: ──────┤ H ├─────────■──┤ Delay(100[dt]) ├──────┤ X ├───────»
┌─────┴───┴─────┐ ┌─┴─┐└────────────────┘┌─────┴───┴──────┐»
q_1: ┤ Delay(50[dt]) ├─┤ X ├────────■─────────┤ Delay(300[dt]) ├»
├───────────────┴┐└───┘ ┌─┴─┐ └────────────────┘»
q_2: ┤ Delay(750[dt]) ├───────────┤ X ├───────────────■─────────»
├────────────────┤ └───┘ ┌─┴─┐ »
q_3: ┤ Delay(950[dt]) ├─────────────────────────────┤ X ├───────»
└────────────────┘ └───┘ »
meas: 4/═══════════════════════════════════════════════════════════»
»
« ┌────────────────┐┌───┐┌────────────────┐ ░ ┌─┐
« q_0: ┤ Delay(200[dt]) ├┤ X ├┤ Delay(100[dt]) ├─░─┤M├─────────
« └────────────────┘└───┘└────────────────┘ ░ └╥┘┌─┐
« q_1: ──────────────────────────────────────────░──╫─┤M├──────
« ░ ║ └╥┘┌─┐
« q_2: ──────────────────────────────────────────░──╫──╫─┤M├───
« ░ ║ ║ └╥┘┌─┐
« q_3: ──────────────────────────────────────────░──╫──╫──╫─┤M├
« ░ ║ ║ ║ └╥┘
«meas: 4/═════════════════════════════════════════════╩══╩══╩══╩═
« 0 1 2 3
"""
dd_sequence = [XGate(), XGate()]
pm = PassManager(
[
ALAPSchedule(self.durations),
DynamicalDecoupling(self.durations, dd_sequence, qubits=[0]),
]
)
ghz4_dd = pm.run(self.ghz4.measure_all(inplace=False))
expected = self.ghz4.copy()
expected = expected.compose(Delay(50), [1], front=True)
expected = expected.compose(Delay(750), [2], front=True)
expected = expected.compose(Delay(950), [3], front=True)
expected = expected.compose(Delay(100), [0])
expected = expected.compose(XGate(), [0])
expected = expected.compose(Delay(200), [0])
expected = expected.compose(XGate(), [0])
expected = expected.compose(Delay(100), [0])
expected = expected.compose(Delay(300), [1])
expected.measure_all()
self.assertEqual(ghz4_dd, expected)
def test_insert_midmeas_hahn_alap(self):
"""Test a single X gate as Hahn echo can absorb in the downstream circuit.
global phase: 3π/2
┌────────────────┐ ┌───┐ ┌────────────────┐»
q_0: ────────■─────────┤ Delay(625[dt]) ├───────┤ X ├───────┤ Delay(625[dt]) ├»
┌─┴─┐ └────────────────┘┌──────┴───┴──────┐└────────────────┘»
q_1: ──────┤ X ├───────────────■─────────┤ Delay(1000[dt]) ├────────■─────────»
┌─────┴───┴──────┐ ┌─┴─┐ └───────┬─┬───────┘ ┌─┴─┐ »
q_2: ┤ Delay(700[dt]) ├──────┤ X ├───────────────┤M├──────────────┤ X ├───────»
└────────────────┘ └───┘ └╥┘ └───┘ »
c: 1/═════════════════════════════════════════════╩═══════════════════════════»
0 »
« ┌───────────────┐
«q_0: ┤ U(0,π/2,-π/2) ├───■──
« └───────────────┘ ┌─┴─┐
«q_1: ──────────────────┤ X ├
« ┌────────────────┐└───┘
«q_2: ┤ Delay(700[dt]) ├─────
« └────────────────┘
«c: 1/═══════════════════════
"""
dd_sequence = [XGate()]
pm = PassManager([
ALAPScheduleAnalysis(self.durations),
PadDynamicalDecoupling(self.durations, dd_sequence),
])
midmeas_dd = pm.run(self.midmeas)
combined_u = UGate(0, pi / 2, -pi / 2)
expected = QuantumCircuit(3, 1)
expected.cx(0, 1)
expected.delay(625, 0)
expected.x(0)
expected.delay(625, 0)
expected.compose(combined_u, [0], inplace=True)
expected.delay(700, 2)
expected.cx(1, 2)
expected.delay(1000, 1)
expected.measure(2, 0)
expected.cx(1, 2)
expected.cx(0, 1)
expected.delay(700, 2)
expected.global_phase = 4.71238898038469
self.assertEqual(midmeas_dd, expected)
# check the absorption into U was done correctly
self.assertEqual(Operator(combined_u),
Operator(XGate()) & Operator(XGate()))
def test_open_controlled_gate(self):
"""
Test controlled gates with control on '0'
"""
base_gate = XGate()
base_mat = base_gate.to_matrix()
num_ctrl_qubits = 3
ctrl_state = 5
cgate = base_gate.control(num_ctrl_qubits, ctrl_state=ctrl_state)
target_mat = _compute_control_matrix(base_mat, num_ctrl_qubits, ctrl_state=ctrl_state)
self.assertEqual(Operator(cgate), Operator(target_mat))
ctrl_state = None
cgate = base_gate.control(num_ctrl_qubits, ctrl_state=ctrl_state)
target_mat = _compute_control_matrix(base_mat, num_ctrl_qubits, ctrl_state=ctrl_state)
self.assertEqual(Operator(cgate), Operator(target_mat))
ctrl_state = 0
cgate = base_gate.control(num_ctrl_qubits, ctrl_state=ctrl_state)
target_mat = _compute_control_matrix(base_mat, num_ctrl_qubits, ctrl_state=ctrl_state)
self.assertEqual(Operator(cgate), Operator(target_mat))
ctrl_state = 7
cgate = base_gate.control(num_ctrl_qubits, ctrl_state=ctrl_state)
target_mat = _compute_control_matrix(base_mat, num_ctrl_qubits, ctrl_state=ctrl_state)
self.assertEqual(Operator(cgate), Operator(target_mat))
ctrl_state = '110'
cgate = base_gate.control(num_ctrl_qubits, ctrl_state=ctrl_state)
target_mat = _compute_control_matrix(base_mat, num_ctrl_qubits, ctrl_state=ctrl_state)
self.assertEqual(Operator(cgate), Operator(target_mat))
def test_gates_with_parameters(self):
"""Check commutativity between (non-parameterized) gates with parameters."""
comm_checker = CommutationChecker()
res = comm_checker.commute(RZGate(0), [0], [], XGate(), [0], [])
self.assertTrue(res)
res = comm_checker.commute(RZGate(np.pi / 2), [0], [], XGate(), [0],
[])
self.assertFalse(res)
res = comm_checker.commute(RZGate(np.pi / 2), [0], [], RZGate(0), [0],
[])
self.assertTrue(res)
def test_instructions(self):
self.assertEqual(self.empty_target.instructions, [])
ibm_expected = [
(IGate(), (0, )),
(IGate(), (1, )),
(IGate(), (2, )),
(IGate(), (3, )),
(IGate(), (4, )),
(RZGate(self.theta), (0, )),
(RZGate(self.theta), (1, )),
(RZGate(self.theta), (2, )),
(RZGate(self.theta), (3, )),
(RZGate(self.theta), (4, )),
(SXGate(), (0, )),
(SXGate(), (1, )),
(SXGate(), (2, )),
(SXGate(), (3, )),
(SXGate(), (4, )),
(XGate(), (0, )),
(XGate(), (1, )),
(XGate(), (2, )),
(XGate(), (3, )),
(XGate(), (4, )),
(CXGate(), (3, 4)),
(CXGate(), (4, 3)),
(CXGate(), (3, 1)),
(CXGate(), (1, 3)),
(CXGate(), (1, 2)),
(CXGate(), (2, 1)),
(CXGate(), (0, 1)),
(CXGate(), (1, 0)),
(Measure(), (0, )),
(Measure(), (1, )),
(Measure(), (2, )),
(Measure(), (3, )),
(Measure(), (4, )),
]
self.assertEqual(ibm_expected, self.ibm_target.instructions)
ideal_sim_expected = [
(UGate(self.theta, self.phi, self.lam), None),
(RXGate(self.theta), None),
(RYGate(self.theta), None),
(RZGate(self.theta), None),
(CXGate(), None),
(ECRGate(), None),
(CCXGate(), None),
(Measure(), None),
]
self.assertEqual(ideal_sim_expected,
self.ideal_sim_target.instructions)
def test_is_identity(self):
"""The is_identity function determines whether a pair of gates
forms the identity, when ignoring control qubits.
"""
seq = [DAGOpNode(op=XGate().control()), DAGOpNode(op=XGate().control(2))]
self.assertTrue(HoareOptimizer()._is_identity(seq))
seq = [
DAGOpNode(op=RZGate(-pi / 2).control()),
DAGOpNode(op=RZGate(pi / 2).control(2)),
]
self.assertTrue(HoareOptimizer()._is_identity(seq))
seq = [DAGOpNode(op=CSwapGate()), DAGOpNode(op=SwapGate())]
self.assertTrue(HoareOptimizer()._is_identity(seq))
def test_is_identity(self):
""" The is_identity function determines whether a pair of gates
forms the identity, when ignoring control qubits.
"""
seq = [DAGNode({'type': 'op', 'op': XGate().control()}),
DAGNode({'type': 'op', 'op': XGate().control(2)})]
self.assertTrue(HoareOptimizer()._is_identity(seq))
seq = [DAGNode({'type': 'op', 'op': RZGate(-pi/2).control()}),
DAGNode({'type': 'op', 'op': RZGate(pi/2).control(2)})]
self.assertTrue(HoareOptimizer()._is_identity(seq))
seq = [DAGNode({'type': 'op', 'op': CSwapGate()}),
DAGNode({'type': 'op', 'op': SwapGate()})]
self.assertTrue(HoareOptimizer()._is_identity(seq))
def test_multi_control_toffoli_matrix_advanced_dirty_ancillas(
self, num_controls):
"""Test the multi-control Toffoli gate with dirty ancillas (advanced).
Based on the test moved here from Aqua:
https://github.com/Qiskit/qiskit-aqua/blob/769ca8f/test/aqua/test_mct.py
"""
q_controls = QuantumRegister(num_controls)
q_target = QuantumRegister(1)
qc = QuantumCircuit(q_controls, q_target)
q_ancillas = None
if num_controls <= 4:
num_ancillas = 0
else:
num_ancillas = 1
q_ancillas = QuantumRegister(num_ancillas)
qc.add_register(q_ancillas)
qc.mct(q_controls, q_target[0], q_ancillas, mode='advanced')
simulated = execute(
qc,
BasicAer.get_backend('unitary_simulator')).result().get_unitary(qc)
if num_ancillas > 0:
simulated = simulated[:2**(num_controls + 1), :2**(num_controls +
1)]
base = XGate().to_matrix()
expected = _compute_control_matrix(base, num_controls)
self.assertTrue(matrix_equal(simulated, expected, atol=1e-8))
def _load_rb_data(self, rb_exp_data_file_name: str):
"""
loader for the experiment data and configuration setup.
Args:
rb_exp_data_file_name(str): The file name that contain the experiment data.
Returns:
list: containing dict of the experiment setup configuration and list of dictionaries
containing the experiment results.
ExperimentData: ExperimentData object that was creates by the analysis function.
"""
interleaved_gates = {"x": XGate(), "cx": CXGate()}
data, exp_attributes, expdata1 = self._load_json_data(
rb_exp_data_file_name)
rb_exp = InterleavedRB(
interleaved_gates[exp_attributes["interleaved_element"]],
exp_attributes["physical_qubits"],
exp_attributes["lengths"],
num_samples=exp_attributes["num_samples"],
seed=exp_attributes["seed"],
)
gate_error_ratio = {
((0, ), "id"): 1,
((0, ), "rz"): 0,
((0, ), "sx"): 1,
((0, ), "x"): 1,
((0, 1), "cx"): 1,
}
rb_exp.analysis.set_options(gate_error_ratio=gate_error_ratio)
analysis_results = rb_exp.analysis.run(expdata1).block_for_results()
return data, analysis_results
def __init__(self):
# |0> Zp rotation
prep_zp = QuantumCircuit(1, name="PauliPrepZp")
# |1> Zm rotation
prep_zm = QuantumCircuit(1, name="PauliPrepZm")
prep_zm.append(XGate(), [0])
# |+> Xp rotation
prep_xp = QuantumCircuit(1, name="PauliPrepXp")
prep_xp.append(HGate(), [0])
# |-> Xm rotation
prep_xm = QuantumCircuit(1, name="PauliPrepXm")
prep_xm.append(HGate(), [0])
prep_xm.append(ZGate(), [0])
# |+i> Yp rotation
prep_yp = QuantumCircuit(1, name="PauliPrepYp")
prep_yp.append(HGate(), [0])
prep_yp.append(SGate(), [0])
# |-i> Ym rotation
prep_ym = QuantumCircuit(1, name="PauliPrepYm")
prep_ym.append(HGate(), [0])
prep_ym.append(SdgGate(), [0])
super().__init__(
[
prep_zp,
prep_zm,
prep_xp,
prep_xm,
prep_yp,
prep_ym,
]
)
def test_caching_negative_results(self):
"""Check that hashing negative results in commutativity checker works as expected."""
comm_checker = CommutationChecker()
res = comm_checker.commute(XGate(), [0], [], CXGate(), [0, 1], [])
self.assertFalse(res)
self.assertGreater(len(comm_checker.cache), 0)
def test_initial_state_as_circuit_object(self):
"""Test setting `initial_state` to `QuantumCircuit` object"""
# ┌───┐ ┌───┐
# q_0: ──■──┤ X ├───────■──┤ X ├
# ┌─┴─┐├───┤┌───┐┌─┴─┐├───┤
# q_1: ┤ X ├┤ H ├┤ X ├┤ X ├┤ X ├
# └───┘└───┘└───┘└───┘└───┘
ref = QuantumCircuit(2)
ref.cx(0, 1)
ref.x(0)
ref.h(1)
ref.x(1)
ref.cx(0, 1)
ref.x(0)
ref.x(1)
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.h(1)
expected = NLocal(
num_qubits=2,
rotation_blocks=XGate(),
entanglement_blocks=CXGate(),
initial_state=qc,
reps=1,
)
self.assertCircuitEqual(ref, expected)
def test_relative_phase_toffoli_gates(self, num_ctrl_qubits):
"""Test the relative phase Toffoli gates.
This test compares the matrix representation of the relative phase gate classes
(i.e. RCCXGate().to_matrix()), the matrix obtained from the unitary simulator,
and the exact version of the gate as obtained through `_compute_control_matrix`.
"""
# get target matrix (w/o relative phase)
base_mat = XGate().to_matrix()
target_mat = _compute_control_matrix(base_mat, num_ctrl_qubits)
# build the matrix for the relative phase toffoli using the unitary simulator
circuit = QuantumCircuit(num_ctrl_qubits + 1)
if num_ctrl_qubits == 2:
circuit.rccx(0, 1, 2)
else: # num_ctrl_qubits == 3:
circuit.rcccx(0, 1, 2, 3)
simulator = BasicAer.get_backend('unitary_simulator')
simulated_mat = execute(circuit, simulator).result().get_unitary()
# get the matrix representation from the class itself
if num_ctrl_qubits == 2:
repr_mat = RCCXGate().to_matrix()
else: # num_ctrl_qubits == 3:
repr_mat = RC3XGate().to_matrix()
# test up to phase
# note, that all entries may have an individual phase! (as opposed to a global phase)
self.assertTrue(matrix_equal(np.abs(simulated_mat), target_mat))
# compare simulated matrix with the matrix representation provided by the class
self.assertTrue(matrix_equal(simulated_mat, repr_mat))
def test_entanglement_by_str(self, entanglement):
"""Test setting the entanglement of the layers by str."""
reps = 3
nlocal = NLocal(5, rotation_blocks=XGate(), entanglement_blocks=CCXGate(),
entanglement=entanglement, reps=reps)
def get_expected_entangler_map(rep_num, mode):
if mode == 'linear':
return [(0, 1, 2), (1, 2, 3), (2, 3, 4)]
elif mode == 'full':
return [(0, 1, 2), (0, 1, 3), (0, 1, 4), (0, 2, 3), (0, 2, 4), (0, 3, 4),
(1, 2, 3), (1, 2, 4), (1, 3, 4),
(2, 3, 4)]
else:
circular = [(3, 4, 0), (0, 1, 2), (1, 2, 3), (2, 3, 4)]
if mode == 'circular':
return circular
sca = circular[-rep_num:] + circular[:-rep_num]
if rep_num % 2 == 1:
sca = [tuple(reversed(indices)) for indices in sca]
return sca
for rep_num in range(reps):
entangler_map = nlocal.get_entangler_map(rep_num, 0, 3)
if isinstance(entanglement, list):
mode = entanglement[rep_num % len(entanglement)]
else:
mode = entanglement
expected = get_expected_entangler_map(rep_num, mode)
with self.subTest(rep_num=rep_num):
# using a set here since the order does not matter
self.assertEqual(set(entangler_map), set(expected))
def test_get_instructions_for_qargs(self):
with self.assertRaises(KeyError):
self.empty_target.operations_for_qargs((0, ))
expected = [RZGate(self.theta), IGate(), SXGate(), XGate(), Measure()]
res = self.ibm_target.operations_for_qargs((0, ))
for gate in expected:
self.assertIn(gate, res)
expected = [ECRGate()]
res = self.fake_backend_target.operations_for_qargs((1, 0))
for gate in expected:
self.assertIn(gate, res)
expected = [CXGate()]
res = self.fake_backend_target.operations_for_qargs((0, 1))
self.assertEqual(expected, res)
ideal_sim_expected = [
UGate(self.theta, self.phi, self.lam),
RXGate(self.theta),
RYGate(self.theta),
RZGate(self.theta),
CXGate(),
ECRGate(),
CCXGate(),
Measure(),
]
for gate in ideal_sim_expected:
self.assertIn(gate,
self.ideal_sim_target.operations_for_qargs(None))
def test_skip_unentangled_qubits(self):
"""Test skipping the unentangled qubits."""
num_qubits = 6
entanglement_1 = [[0, 1, 3], [1, 3, 5], [0, 1, 5]]
skipped_1 = [2, 4]
entanglement_2 = [entanglement_1, [[0, 1, 2], [2, 3, 5]]]
skipped_2 = [4]
for entanglement, skipped in zip([entanglement_1, entanglement_2],
[skipped_1, skipped_2]):
with self.subTest(entanglement=entanglement, skipped=skipped):
nlocal = NLocal(
num_qubits,
rotation_blocks=XGate(),
entanglement_blocks=CCXGate(),
entanglement=entanglement,
reps=3,
skip_unentangled_qubits=True,
)
skipped_set = set(nlocal.qubits[i] for i in skipped)
dag = circuit_to_dag(nlocal)
idle = set(dag.idle_wires())
self.assertEqual(skipped_set, idle)
def Agate(numLis, inverse=False, plot_gate=False):
if len(numLis) != 6:
raise Exception("Parameter Lis error!")
qr = QuantumRegister(2)
qc = QuantumCircuit(qr)
qc.cz(qr[0], qr[1])
qc.rx(numLis[0], qr[1])
sqrtXdg = XGate().power(0.5).inverse()
qc.append(sqrtXdg, qargs=[qr[1]])
qc.append(myRzz(numLis[1]).control(), qargs=qr[:])
if plot_gate:
qc.barrier()
qc.rx(numLis[2], qr[0])
qc.append(myRzz(numLis[3]).control(), qargs=[qr[1]] + [qr[0]])
qc.cx(qr[0], qr[1])
qc.rx(numLis[4], qr[0])
qc.cx(qr[0], qr[1])
qc.cz(qr[0], qr[1])
#print(qc)
if plot_gate:
print(qc)
return
ret = qc.to_gate()
if inverse:
ret.inverse()
ret.name = f'gate_1/{numLis[5]}'
return ret
def test_multi_control_toffoli_matrix_clean_ancillas(self, num_controls):
"""Test the multi-control Toffoli gate with clean ancillas.
Based on the test moved here from Aqua:
https://github.com/Qiskit/qiskit-aqua/blob/769ca8f/test/aqua/test_mct.py
"""
# set up circuit
q_controls = QuantumRegister(num_controls)
q_target = QuantumRegister(1)
qc = QuantumCircuit(q_controls, q_target)
if num_controls > 2:
num_ancillas = num_controls - 2
q_ancillas = QuantumRegister(num_controls)
qc.add_register(q_ancillas)
else:
num_ancillas = 0
q_ancillas = None
# apply hadamard on control qubits and toffoli gate
qc.mct(q_controls, q_target[0], q_ancillas, mode='basic')
# execute the circuit and obtain statevector result
backend = BasicAer.get_backend('unitary_simulator')
simulated = execute(qc, backend).result().get_unitary(qc)
# compare to expectation
if num_ancillas > 0:
simulated = simulated[:2**(num_controls + 1), :2**(num_controls +
1)]
base = XGate().to_matrix()
expected = _compute_control_matrix(base, num_controls)
self.assertTrue(matrix_equal(simulated, expected))
def test_can_append_to_quantum_circuit(self):
"""Test that we can add various objects with Operation interface to a Quantum Circuit."""
qc = QuantumCircuit(6, 1)
qc.append(XGate(), [2])
qc.append(Barrier(3), [1, 2, 4])
qc.append(CXGate(), [0, 1])
qc.append(Measure(), [1], [0])
qc.append(Reset(), [0])
qc.cx(3, 4)
qc.append(Gate("some_gate", 3, []), [1, 2, 3])
qc.append(Initialize([0.5, 0.5, 0.5, 0.5]), [4, 5])
qc.append(Isometry(np.eye(4, 4), 0, 0), [3, 4])
qc.append(Pauli("II"), [0, 1])
# Appending Clifford
circ1 = QuantumCircuit(2)
circ1.h(1)
circ1.cx(0, 1)
qc.append(Clifford(circ1), [0, 1])
# Appending CNOTDihedral
circ2 = QuantumCircuit(2)
circ2.t(0)
circ2.x(0)
circ2.t(1)
qc.append(CNOTDihedral(circ2), [2, 3])
# If we got to here, we have successfully appended everything to qc
self.assertIsInstance(qc, QuantumCircuit)
def test_pairwise_entanglement_raises(self):
"""Test choosing pairwise entanglement raises an error for too large blocks."""
nlocal = NLocal(3, XGate(), CCXGate(), entanglement='pairwise', reps=1)
# pairwise entanglement is only defined if the entangling gate has 2 qubits
with self.assertRaises(ValueError):
print(nlocal.draw())
def to_circuit(self) -> QuantumCircuit:
pauli = self.primitive.to_label()[-self.num_qubits:]
phase = self.primitive.phase
qc = QuantumCircuit(self.num_qubits)
if pauli == "I" * self.num_qubits:
qc.global_phase = -phase * pi / 2
return qc
if self.num_qubits == 1:
gate = {
"I": IGate(),
"X": XGate(),
"Y": YGate(),
"Z": ZGate()
}[pauli]
else:
gate = PauliGate(pauli)
qc.append(gate, range(self.num_qubits))
if not phase:
return qc
qc.global_phase = -phase * pi / 2
return qc
