def test_clifford_as_operation(self):
"""Test that we can instantiate an object of class
:class:`~qiskit.quantum_info.operators.Clifford` and that
it has the expected name, num_qubits and num_clbits.
"""
num_qubits = 4
qc = QuantumCircuit(4, 0)
qc.h(2)
qc.cx(0, 1)
op = Clifford(qc)
self.assertTrue(op.name == "clifford")
self.assertTrue(op.num_qubits == num_qubits)
self.assertTrue(op.num_clbits == 0)
self.assertIsInstance(op, Operation)
def test_transpose(self, num_qubits):
"""Test transpose method"""
samples = 10
num_gates = 1
seed = 500
gates = "all"
for i in range(samples):
circ = random_clifford_circuit(num_qubits,
num_gates,
gates=gates,
seed=seed + i)
value = Clifford(circ).transpose().to_operator()
target = Operator(circ).transpose()
self.assertTrue(target.equiv(value))
def test_conjugate(self, num_qubits):
"""Test conjugate method"""
samples = 10
num_gates = 10
seed = 400
gates = 'all'
for i in range(samples):
circ = random_clifford_circuit(num_qubits,
num_gates,
gates=gates,
seed=seed + i)
value = Clifford(circ).conjugate().to_operator()
target = Operator(circ).conjugate()
self.assertTrue(target.equiv(value))
def test_1_qubit_mult_relations(self):
"""Tests multiplicity relations for 1-qubit gates"""
rels = [
"x * y = z",
"x * z = y",
"y * z = x",
"s * s = z",
"sdg * sdg = z",
"sinv * sinv = z",
"sdg * h = v",
"h * s = w",
]
for rel in rels:
with self.subTest(msg="relation %s" % rel):
split_rel = rel.split()
cliff = Clifford([[1, 0], [0, 1]])
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, split_rel[0], [0])
cliff = _append_circuit(cliff, split_rel[2], [0])
cliff1 = _append_circuit(cliff1, split_rel[4], [0])
self.assertEqual(cliff, cliff1)
def create_cliff3(self):
"""Creates a third Clifford which is the composition of the previous two."""
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
qc.s(2)
qc.cx(0, 1)
qc.h(0)
qc.h(1)
qc.h(2)
qc.cx(1, 2)
qc.s(2)
return Clifford(qc)
def test_append_2_qubit_gate(self, gate_name, qubits):
"""Tests for append of 2-qubit gate {gate_name} {qubits}."""
targets_cliffords = {
"cx [0, 1]":
Clifford([
[True, True, False, False],
[False, True, False, False],
[False, False, True, False],
[False, False, True, True],
]),
"cx [1, 0]":
Clifford([
[True, False, False, False],
[True, True, False, False],
[False, False, True, True],
[False, False, False, True],
]),
"cz [0, 1]":
Clifford([
[True, False, False, True],
[False, True, True, False],
[False, False, True, False],
[False, False, False, True],
]),
"cz [1, 0]":
Clifford([
[True, False, False, True],
[False, True, True, False],
[False, False, True, False],
[False, False, False, True],
]),
"swap [0, 1]":
Clifford([
[False, True, False, False],
[True, False, False, False],
[False, False, False, True],
[False, False, True, False],
]),
"swap [1, 0]":
Clifford([
[False, True, False, False],
[True, False, False, False],
[False, False, False, True],
[False, False, True, False],
]),
}
gate_qubits = gate_name + " " + str(qubits)
cliff = _append_circuit(Clifford(np.eye(4)), gate_name, qubits)
target = targets_cliffords[gate_qubits]
self.assertEqual(target, cliff)
def test_expand_method(self, num_qubits_1, num_qubits_2):
"""Test expand method"""
samples = 5
num_gates = 10
seed = 800
gates = 'all'
for i in range(samples):
circ1 = random_clifford_circuit(num_qubits_1,
num_gates,
gates=gates,
seed=seed + i)
circ2 = random_clifford_circuit(num_qubits_2,
num_gates,
gates=gates,
seed=seed + samples + i)
cliff1 = Clifford(circ1)
cliff2 = Clifford(circ2)
value = cliff1.expand(cliff2)
circ = QuantumCircuit(num_qubits_1 + num_qubits_2)
circ.append(circ1, range(num_qubits_1))
circ.append(circ2, range(num_qubits_1,
num_qubits_1 + num_qubits_2))
target = Clifford(circ)
self.assertEqual(target, value)
def test_compose_subsystem(self, num_qubits_1, num_qubits_2):
"""Test compose method of subsystems"""
samples = 10
num_gates = 10
seed = 600
gates = 'all'
for i in range(samples):
circ1 = random_clifford_circuit(num_qubits_1,
num_gates,
gates=gates,
seed=seed + i)
circ2 = random_clifford_circuit(num_qubits_2,
num_gates,
gates=gates,
seed=seed + samples + i)
qargs = sorted(
np.random.choice(range(num_qubits_1),
num_qubits_2,
replace=False))
circ = circ1.copy()
circ.append(circ2.to_instruction(), qargs)
value = Clifford(circ1).compose(Clifford(circ2), qargs)
target = Clifford(circ)
self.assertEqual(target, value)
def test_to_matrix(self, num_qubits):
"""Test to_matrix method"""
samples = 10
num_gates = 10
seed = 333
gates = 'all'
for i in range(samples):
circ = random_clifford_circuit(num_qubits,
num_gates,
gates=gates,
seed=seed + i)
mat = Clifford(circ).to_matrix()
self.assertIsInstance(mat, np.ndarray)
self.assertEqual(mat.shape, 2 * (2**num_qubits, ))
value = Operator(mat)
target = Operator(circ)
self.assertTrue(value.equiv(target))
def test_to_instruction(self, num_qubits):
"""Test to_instruction method"""
samples = 10
num_gates = 10
seed = 800
gates = 'all'
for i in range(samples):
circ = random_clifford_circuit(num_qubits,
num_gates,
gates=gates,
seed=seed + i)
decomp = Clifford(circ).to_instruction()
self.assertIsInstance(decomp, Gate)
self.assertEqual(decomp.num_qubits, circ.num_qubits)
value = Operator(decomp)
target = Operator(circ)
self.assertTrue(value.equiv(target))
def test_1_qubit_identity_relations(self):
"""Tests identity relations for 1-qubit gates"""
for gate_name in ("x", "y", "z", "h"):
with self.subTest(msg='identity for gate %s' % gate_name):
cliff = Clifford([[1, 0], [0, 1]])
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, gate_name, [0])
cliff = _append_circuit(cliff, gate_name, [0])
self.assertEqual(cliff, cliff1)
gates = ['s', 's', 'v']
inv_gates = ['sdg', 'sinv', 'w']
for gate_name, inv_gate in zip(gates, inv_gates):
with self.subTest(msg='identity for gate %s' % gate_name):
cliff = Clifford([[1, 0], [0, 1]])
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, gate_name, [0])
cliff = _append_circuit(cliff, inv_gate, [0])
self.assertEqual(cliff, cliff1)
def test_to_dict(self):
"""Test to_dict method"""
with self.subTest(msg="Identity"):
cliff = Clifford(np.eye(8))
value = cliff.to_dict()
keys_value = set(value.keys())
keys_target = {'destabilizer', 'stabilizer'}
self.assertEqual(keys_value, keys_target)
stabilizer_value = set(value['stabilizer'])
stabilizer_target = {'+IIIZ', '+IIZI', '+IZII', '+ZIII'}
self.assertEqual(stabilizer_value, stabilizer_target)
destabilizer_value = set(value['destabilizer'])
destabilizer_target = {'+IIIX', '+IIXI', '+IXII', '+XIII'}
self.assertEqual(destabilizer_value, destabilizer_target)
with self.subTest(msg="bell"):
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
cliff = Clifford(qc)
value = cliff.to_dict()
keys_value = set(value.keys())
keys_target = {'destabilizer', 'stabilizer'}
self.assertEqual(keys_value, keys_target)
stabilizer_value = set(value['stabilizer'])
stabilizer_target = {'+XX', '+ZZ'}
self.assertEqual(stabilizer_value, stabilizer_target)
destabilizer_value = set(value['destabilizer'])
destabilizer_target = {'+IZ', '+XI'}
self.assertEqual(destabilizer_value, destabilizer_target)
def test_to_dict(self):
"""Test to_dict method"""
with self.subTest(msg="Identity"):
cliff = Clifford(np.eye(8))
value = cliff.to_dict()
keys_value = set(value.keys())
keys_target = {"destabilizer", "stabilizer"}
self.assertEqual(keys_value, keys_target)
stabilizer_value = set(value["stabilizer"])
stabilizer_target = {"+IIIZ", "+IIZI", "+IZII", "+ZIII"}
self.assertEqual(stabilizer_value, stabilizer_target)
destabilizer_value = set(value["destabilizer"])
destabilizer_target = {"+IIIX", "+IIXI", "+IXII", "+XIII"}
self.assertEqual(destabilizer_value, destabilizer_target)
with self.subTest(msg="bell"):
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
cliff = Clifford(qc)
value = cliff.to_dict()
keys_value = set(value.keys())
keys_target = {"destabilizer", "stabilizer"}
self.assertEqual(keys_value, keys_target)
stabilizer_value = set(value["stabilizer"])
stabilizer_target = {"+XX", "+ZZ"}
self.assertEqual(stabilizer_value, stabilizer_target)
destabilizer_value = set(value["destabilizer"])
destabilizer_target = {"+IZ", "+XI"}
self.assertEqual(destabilizer_value, destabilizer_target)
def run(self, dag):
"""Run the OptimizeCliffords pass on `dag`.
Args:
dag (DAGCircuit): the DAG to be optimized.
Returns:
DAGCircuit: the optimized DAG.
"""
blocks = []
prev_node = None
cur_block = []
# Iterate over all nodes and collect consecutive Cliffords over the
# same qubits. In this very first proof-of-concept implementation
# we require the same ordering of qubits, but this restriction will
# be shortly removed. An interesting question is whether we may also
# want to compose Cliffords over different sets of qubits, such as
# cliff1 over qubits [1, 2, 3] and cliff2 over [2, 3, 4].
for node in dag.topological_op_nodes():
if isinstance(node.op, Clifford):
if prev_node is None:
blocks.append(cur_block)
cur_block = [node]
else:
if prev_node.qargs == node.qargs:
cur_block.append(node)
else:
blocks.append(cur_block)
cur_block = [node]
prev_node = node
else:
# not a clifford
if cur_block:
blocks.append(cur_block)
prev_node = None
cur_block = []
if cur_block:
blocks.append(cur_block)
# Replace every discovered block of cliffords by a single clifford
# based on the Cliffords' compose function.
for cur_nodes in blocks:
# Create clifford functions only out of blocks with at least 2 gates
if len(cur_nodes) <= 1:
continue
wire_pos_map = dict(
(qb, ix) for ix, qb in enumerate(cur_nodes[0].qargs))
# Construct a linear circuit
cliff = cur_nodes[0].op
for i, node in enumerate(cur_nodes):
if i > 0:
cliff = Clifford.compose(node.op, cliff, front=True)
# Replace the block by the composed clifford
dag.replace_block_with_op(cur_nodes,
cliff,
wire_pos_map,
cycle_check=False)
return dag
def test_2_qubit_relations(self):
"""Tests relations for 2-qubit gates"""
with self.subTest(msg="relation between cx, h and cz"):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, "h", [1])
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "h", [1])
cliff = _append_circuit(cliff, "cz", [0, 1])
self.assertEqual(cliff, cliff1)
with self.subTest(msg="relation between cx and swap"):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "cx", [1, 0])
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "swap", [0, 1])
self.assertEqual(cliff, cliff1)
with self.subTest(msg="relation between cx and x"):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "x", [0])
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "x", [0])
cliff = _append_circuit(cliff, "x", [1])
self.assertEqual(cliff, cliff1)
with self.subTest(msg="relation between cx and z"):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "z", [1])
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "z", [0])
cliff = _append_circuit(cliff, "z", [1])
self.assertEqual(cliff, cliff1)
with self.subTest(msg="relation between cx and s"):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, "cx", [1, 0])
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "s", [1])
cliff = _append_circuit(cliff, "cx", [0, 1])
cliff = _append_circuit(cliff, "cx", [1, 0])
cliff = _append_circuit(cliff, "sdg", [0])
self.assertEqual(cliff, cliff1)
def test_append_1_qubit_gate(self):
"""Tests for append of 1-qubit gates"""
target_table = {
"i": np.array([[[True, False], [False, True]]], dtype=bool),
"id": np.array([[[True, False], [False, True]]], dtype=bool),
"iden": np.array([[[True, False], [False, True]]], dtype=bool),
"x": np.array([[[True, False], [False, True]]], dtype=bool),
"y": np.array([[[True, False], [False, True]]], dtype=bool),
"z": np.array([[[True, False], [False, True]]], dtype=bool),
"h": np.array([[[False, True], [True, False]]], dtype=bool),
"s": np.array([[[True, True], [False, True]]], dtype=bool),
"sdg": np.array([[[True, True], [False, True]]], dtype=bool),
"sinv": np.array([[[True, True], [False, True]]], dtype=bool),
"v": np.array([[[True, True], [True, False]]], dtype=bool),
"w": np.array([[[False, True], [True, True]]], dtype=bool),
}
target_phase = {
"i": np.array([[False, False]], dtype=bool),
"id": np.array([[False, False]], dtype=bool),
"iden": np.array([[False, False]], dtype=bool),
"x": np.array([[False, True]], dtype=bool),
"y": np.array([[True, True]], dtype=bool),
"z": np.array([[True, False]], dtype=bool),
"h": np.array([[False, False]], dtype=bool),
"s": np.array([[False, False]], dtype=bool),
"sdg": np.array([[True, False]], dtype=bool),
"sinv": np.array([[True, False]], dtype=bool),
"v": np.array([[False, False]], dtype=bool),
"w": np.array([[False, False]], dtype=bool)
}
target_stabilizer = {
"i": "+Z",
"id": "+Z",
"iden": "+Z",
"x": "-Z",
"y": "-Z",
"z": "+Z",
"h": "+X",
"s": "+Z",
"sdg": "+Z",
"sinv": "+Z",
"v": "+X",
"w": "+Y",
}
target_destabilizer = {
"i": "+X",
"id": "+X",
"iden": "+X",
"x": "+X",
"y": "-X",
"z": "-X",
"h": "+Z",
"s": "+Y",
"sdg": "-Y",
"sinv": "-Y",
"v": "+Y",
"w": "+Z",
}
for gate_name in ("i", "id", "iden", "x", "y", "z", "h", "s", "sdg",
"v", "w"):
with self.subTest(msg='append gate %s' % gate_name):
cliff = Clifford([[1, 0], [0, 1]])
cliff = _append_circuit(cliff, gate_name, [0])
value_table = cliff.table._array
value_phase = cliff.table._phase
value_stabilizer = cliff.stabilizer.to_labels()
value_destabilizer = cliff.destabilizer.to_labels()
self.assertTrue(
np.all(np.array(value_table == target_table[gate_name])))
self.assertTrue(
np.all(np.array(value_phase == target_phase[gate_name])))
self.assertTrue(
np.all(
np.array(value_stabilizer ==
[target_stabilizer[gate_name]])))
self.assertTrue(
np.all(
np.array(value_destabilizer ==
[target_destabilizer[gate_name]])))
def _cliffords_1q(self):
clifford_dicts = [{
"stabilizer": ["+Z"],
"destabilizer": ["-X"]
}, {
"stabilizer": ["-Z"],
"destabilizer": ["+X"]
}, {
"stabilizer": ["-Z"],
"destabilizer": ["-X"]
}, {
"stabilizer": ["+Z"],
"destabilizer": ["+Y"]
}, {
"stabilizer": ["+Z"],
"destabilizer": ["-Y"]
}, {
"stabilizer": ["-Z"],
"destabilizer": ["+Y"]
}, {
"stabilizer": ["-Z"],
"destabilizer": ["-Y"]
}, {
"stabilizer": ["+X"],
"destabilizer": ["+Z"]
}, {
"stabilizer": ["+X"],
"destabilizer": ["-Z"]
}, {
"stabilizer": ["-X"],
"destabilizer": ["+Z"]
}, {
"stabilizer": ["-X"],
"destabilizer": ["-Z"]
}, {
"stabilizer": ["+X"],
"destabilizer": ["+Y"]
}, {
"stabilizer": ["+X"],
"destabilizer": ["-Y"]
}, {
"stabilizer": ["-X"],
"destabilizer": ["+Y"]
}, {
"stabilizer": ["-X"],
"destabilizer": ["-Y"]
}, {
"stabilizer": ["+Y"],
"destabilizer": ["+X"]
}, {
"stabilizer": ["+Y"],
"destabilizer": ["-X"]
}, {
"stabilizer": ["-Y"],
"destabilizer": ["+X"]
}, {
"stabilizer": ["-Y"],
"destabilizer": ["-X"]
}, {
"stabilizer": ["+Y"],
"destabilizer": ["+Z"]
}, {
"stabilizer": ["+Y"],
"destabilizer": ["-Z"]
}, {
"stabilizer": ["-Y"],
"destabilizer": ["+Z"]
}, {
"stabilizer": ["-Y"],
"destabilizer": ["-Z"]
}]
return [Clifford.from_dict(i) for i in clifford_dicts]
def test_2_qubit_relations(self):
"""Tests relations for 2-qubit gates"""
with self.subTest(msg='relation between cx, h and cz'):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, 'h', [1])
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 'h', [1])
cliff = _append_circuit(cliff, 'cz', [0, 1])
self.assertEqual(cliff, cliff1)
with self.subTest(msg='relation between cx and swap'):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 'cx', [1, 0])
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 'swap', [0, 1])
self.assertEqual(cliff, cliff1)
with self.subTest(msg='relation between cx and x'):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 'x', [0])
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 'x', [0])
cliff = _append_circuit(cliff, 'x', [1])
self.assertEqual(cliff, cliff1)
with self.subTest(msg='relation between cx and z'):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 'z', [1])
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 'z', [0])
cliff = _append_circuit(cliff, 'z', [1])
self.assertEqual(cliff, cliff1)
with self.subTest(msg='relation between cx and s'):
cliff = Clifford(np.eye(4))
cliff1 = cliff.copy()
cliff = _append_circuit(cliff, 'cx', [1, 0])
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 's', [1])
cliff = _append_circuit(cliff, 'cx', [0, 1])
cliff = _append_circuit(cliff, 'cx', [1, 0])
cliff = _append_circuit(cliff, 'sdg', [0])
self.assertEqual(cliff, cliff1)
