def test_consecutive_cnots2(self):
"""
Two CNOTs that equals identity, with rotation gates inserted.
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.rx(np.pi, qr[0])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.rx(np.pi, qr[0])
passmanager = PassManager()
passmanager.append(
[
CommutationAnalysis(),
CommutativeCancellation(),
Size(),
FixedPoint("size")
],
do_while=lambda property_set: not property_set["size_fixed_point"],
)
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
self.assertEqual(expected, new_circuit)
def test_cnot_cascade1(self):
"""
A cascade of CNOTs that equals identity, with rotation gates inserted.
"""
qr = QuantumRegister(10, "qr")
circuit = QuantumCircuit(qr)
circuit.rx(np.pi, qr[0])
circuit.rx(np.pi, qr[1])
circuit.rx(np.pi, qr[2])
circuit.rx(np.pi, qr[3])
circuit.rx(np.pi, qr[4])
circuit.rx(np.pi, qr[5])
circuit.rx(np.pi, qr[6])
circuit.rx(np.pi, qr[7])
circuit.rx(np.pi, qr[8])
circuit.rx(np.pi, qr[9])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[5], qr[6])
circuit.cx(qr[6], qr[7])
circuit.cx(qr[7], qr[8])
circuit.cx(qr[8], qr[9])
circuit.cx(qr[8], qr[9])
circuit.cx(qr[7], qr[8])
circuit.cx(qr[6], qr[7])
circuit.cx(qr[5], qr[6])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[0], qr[1])
circuit.rx(np.pi, qr[0])
circuit.rx(np.pi, qr[1])
circuit.rx(np.pi, qr[2])
circuit.rx(np.pi, qr[3])
circuit.rx(np.pi, qr[4])
circuit.rx(np.pi, qr[5])
circuit.rx(np.pi, qr[6])
circuit.rx(np.pi, qr[7])
circuit.rx(np.pi, qr[8])
circuit.rx(np.pi, qr[9])
passmanager = PassManager()
# passmanager.append(CommutativeCancellation())
passmanager.append(
[
CommutationAnalysis(),
CommutativeCancellation(),
Size(),
FixedPoint("size")
],
do_while=lambda property_set: not property_set["size_fixed_point"],
)
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
self.assertEqual(expected, new_circuit)
def test_commutative_circuit3(self):
"""
A simple circuit where three CNOTs commute, the first and the last cancel,
also two X gates cancel and two Rz gates combine.
qr0:-------.------------------.------------- qr0:-------------
| |
qr1:------(+)------(+)--[X]--(+)-------[X]-- = qr1:--------(+)--
| |
qr2:------[Rz]--.---.----.---[Rz]-[T]--[S]-- qr2:--[U1]---.---
| |
qr3:-[Rz]--[X]-(+)------(+)--[X]-[Rz]------- qr3:--[Rz]-------
"""
qr = QuantumRegister(4, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.rz(np.pi / 3, qr[2])
circuit.rz(np.pi / 3, qr[3])
circuit.x(qr[3])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[2], qr[3])
circuit.rz(np.pi / 3, qr[2])
circuit.t(qr[2])
circuit.x(qr[3])
circuit.rz(np.pi / 3, qr[3])
circuit.s(qr[2])
circuit.x(qr[1])
circuit.cx(qr[0], qr[1])
circuit.x(qr[1])
passmanager = PassManager()
passmanager.append(
[
CommutationAnalysis(),
CommutativeCancellation(),
Size(),
FixedPoint("size")
],
do_while=lambda property_set: not property_set["size_fixed_point"],
)
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
expected.append(RZGate(np.pi * 17 / 12), [qr[2]])
expected.append(RZGate(np.pi * 2 / 3), [qr[3]])
expected.cx(qr[2], qr[1])
self.assertEqual(
expected,
new_circuit,
msg=f"expected:\n{expected}\nnew_circuit:\n{new_circuit}")
def test_commutative_circuit3(self):
"""
A simple circuit where three CNOTs commute, the first and the last cancel,
also two X gates cancel and two Rz gates combine.
qr0:-------.------------------.------------- qr0:-------------
| |
qr1:------(+)------(+)--[X]--(+)-------[X]-- = qr1:--------(+)--
| |
qr2:------[Rz]--.---.----.---[Rz]-[T]--[S]-- qr2:--[U1]---.---
| |
qr3:-[Rz]--[X]-(+)------(+)--[X]-[Rz]------- qr3:--[Rz]-------
"""
qr = QuantumRegister(4, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.rz(sympy.pi / 3, qr[2])
circuit.rz(sympy.pi / 3, qr[3])
circuit.x(qr[3])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[2], qr[3])
circuit.rz(sympy.pi / 3, qr[2])
circuit.t(qr[2])
circuit.x(qr[3])
circuit.rz(sympy.pi / 3, qr[3])
circuit.s(qr[2])
circuit.x(qr[1])
circuit.cx(qr[0], qr[1])
circuit.x(qr[1])
passmanager = PassManager()
passmanager.append(
[
CommutationAnalysis(),
CommutativeCancellation(),
Size(),
FixedPoint('size')
],
do_while=lambda property_set: not property_set['size_fixed_point'])
new_circuit = transpile(circuit, pass_manager=passmanager)
expected = QuantumCircuit(qr)
expected.u1(sympy.pi * 17 / 12, qr[2])
expected.u1(sympy.pi * 2 / 3, qr[3])
expected.cx(qr[2], qr[1])
self.assertEqual(expected, new_circuit)
def test_cnot_cascade(self):
"""
A cascade of CNOTs that equals identity.
"""
qr = QuantumRegister(10, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[5], qr[6])
circuit.cx(qr[6], qr[7])
circuit.cx(qr[7], qr[8])
circuit.cx(qr[8], qr[9])
circuit.cx(qr[8], qr[9])
circuit.cx(qr[7], qr[8])
circuit.cx(qr[6], qr[7])
circuit.cx(qr[5], qr[6])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[0], qr[1])
passmanager = PassManager()
# passmanager.append(CommutativeCancellation())
passmanager.append(
[
CommutationAnalysis(),
CommutativeCancellation(),
Size(),
FixedPoint('size')
],
do_while=lambda property_set: not property_set['size_fixed_point'])
new_circuit = transpile(circuit, pass_manager=passmanager)
expected = QuantumCircuit(qr)
self.assertEqual(expected, new_circuit)
def setUp(self):
super().setUp()
self.pass_ = CommutationAnalysis()
self.pset = self.pass_.property_set = PropertySet()
class TestCommutationAnalysis(QiskitTestCase):
"""Test the Commutation pass."""
def setUp(self):
super().setUp()
self.pass_ = CommutationAnalysis()
self.pset = self.pass_.property_set = PropertySet()
def assertCommutationSet(self, result, expected):
"""Compares the result of propertyset["commutation_set"] with a dictionary of the form
{'q[0]': [ [node_id, ...], [node_id, ...] ]}
"""
result_to_compare = {}
for qbit, sets in result.items():
if not isinstance(qbit, Qubit):
continue
result_to_compare[qbit] = []
for commutation_set in sets:
result_to_compare[qbit].append(
sorted(node._node_id for node in commutation_set))
for qbit, sets in expected.items():
for commutation_set in sets:
commutation_set.sort()
self.assertDictEqual(result_to_compare, expected)
def test_commutation_set_property_is_created(self):
"""Test property is created"""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr)
dag = circuit_to_dag(circuit)
self.assertIsNone(self.pset["commutation_set"])
self.pass_.run(dag)
self.assertIsNotNone(self.pset["commutation_set"])
def test_all_gates(self):
"""Test all gates on 1 and 2 qubits
qr0:----[H]---[x]---[y]---[t]---[s]---[rz]---[p]---[u]---[u]---.---.---.--
| | |
qr1:----------------------------------------------------------(+)-(Y)--.--
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.x(qr[0])
circuit.y(qr[0])
circuit.t(qr[0])
circuit.s(qr[0])
circuit.rz(0.5, qr[0])
circuit.p(0.5, qr[0])
circuit.u(1.57, 0.5, 0.6, qr[0])
circuit.u(0.5, 0.6, 0.7, qr[0])
circuit.cx(qr[0], qr[1])
circuit.cy(qr[0], qr[1])
circuit.cz(qr[0], qr[1])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
qr[0]: [[0], [4], [5], [6], [7, 8, 9, 10], [11], [12], [13], [14],
[15], [1]],
qr[1]: [[2], [13], [14], [15], [3]],
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
def test_non_commutative_circuit(self):
"""A simple circuit where no gates commute
qr0:---[H]---
qr1:---[H]---
qr2:---[H]---
"""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr)
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
qr[0]: [[0], [6], [1]],
qr[1]: [[2], [7], [3]],
qr[2]: [[4], [8], [5]]
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
def test_non_commutative_circuit_2(self):
"""A simple circuit where no gates commute
qr0:----.-------------
|
qr1:---(+)------.-----
|
qr2:---[H]-----(+)----
"""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.h(qr[2])
circuit.cx(qr[1], qr[2])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
qr[0]: [[0], [6], [1]],
qr[1]: [[2], [6], [8], [3]],
qr[2]: [[4], [7], [8], [5]],
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
def test_commutative_circuit(self):
"""A simple circuit where two CNOTs commute
qr0:----.------------
|
qr1:---(+)-----(+)---
|
qr2:---[H]------.----
"""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.h(qr[2])
circuit.cx(qr[2], qr[1])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
qr[0]: [[0], [6], [1]],
qr[1]: [[2], [6, 8], [3]],
qr[2]: [[4], [7], [8], [5]]
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
def test_commutative_circuit_2(self):
"""A simple circuit where a CNOT and a Z gate commute,
and a CNOT and a CNOT commute
qr0:----.-----[Z]-----
|
qr1:---(+)----(+)----
|
qr2:---[H]-----.----
"""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.z(qr[0])
circuit.h(qr[2])
circuit.cx(qr[2], qr[1])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
qr[0]: [[0], [6, 7], [1]],
qr[1]: [[2], [6, 9], [3]],
qr[2]: [[4], [8], [9], [5]],
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
def test_commutative_circuit_3(self):
"""A simple circuit where multiple gates commute
qr0:----.-----[Z]-----.----[z]-----
| |
qr1:---(+)----(+)----(+)----.------
| |
qr2:---[H]-----.-----[x]---(+)-----
"""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.h(qr[2])
circuit.z(qr[0])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[0], qr[1])
circuit.x(qr[2])
circuit.z(qr[0])
circuit.cx(qr[1], qr[2])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
qr[0]: [[0], [6, 8, 10, 12], [1]],
qr[1]: [[2], [6, 9, 10], [13], [3]],
qr[2]: [[4], [7], [9], [11, 13], [5]],
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
def test_jordan_wigner_type_circuit(self):
"""A Jordan-Wigner type circuit where consecutive CNOTs commute
qr0:----.-------------------------------------------------------------.----
| |
qr1:---(+)----.-------------------------------------------------.----(+)---
| |
qr2:---------(+)----.-------------------------------------.----(+)---------
| |
qr3:---------------(+)----.-------------------------.----(+)---------------
| |
qr4:---------------------(+)----.-------------.----(+)---------------------
| |
qr5:---------------------------(+)----[z]----(+)---------------------------
"""
qr = QuantumRegister(6, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[4], qr[5])
circuit.z(qr[5])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[0], qr[1])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
qr[0]: [[0], [12, 22], [1]],
qr[1]: [[2], [12], [13, 21], [22], [3]],
qr[2]: [[4], [13], [14, 20], [21], [5]],
qr[3]: [[6], [14], [15, 19], [20], [7]],
qr[4]: [[8], [15], [16, 18], [19], [9]],
qr[5]: [[10], [16], [17], [18], [11]],
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
def test_all_commute_circuit(self):
"""Test circuit with that all commute"""
qr = QuantumRegister(5, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[4], qr[3])
circuit.cx(qr[2], qr[3])
circuit.z(qr[0])
circuit.z(qr[4])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[4], qr[3])
circuit.cx(qr[2], qr[3])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
qr[0]: [[0], [10, 14, 16], [1]],
qr[1]: [[2], [10, 11, 16, 17], [3]],
qr[2]: [[4], [11, 13, 17, 19], [5]],
qr[3]: [[6], [12, 13, 18, 19], [7]],
qr[4]: [[8], [12, 15, 18], [9]],
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
class TestCommutationAnalysis(QiskitTestCase):
"""Test the Communttion pass."""
def setUp(self):
self.pass_ = CommutationAnalysis()
self.pset = self.pass_.property_set = PropertySet()
def test_commutation_set_property_is_created(self):
"""Test property is created"""
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.h(qr)
dag = circuit_to_dag(circuit)
self.assertIsNone(self.pset['commutation_set'])
self.pass_.run(dag)
self.assertIsNotNone(self.pset['commutation_set'])
def test_all_gates(self):
"""Test all gates on 1 and 2 qubits
qr0:----[H]---[x]---[y]---[t]---[s]---[rz]---[u1]---[u2]---[u3]---.---.---.--
| | |
qr1:-------------------------------------------------------------(+)-(Y)--.--
"""
qr = QuantumRegister(2, 'qr')
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.x(qr[0])
circuit.y(qr[0])
circuit.t(qr[0])
circuit.s(qr[0])
circuit.rz(0.5, qr[0])
circuit.u1(0.5, qr[0])
circuit.u2(0.5, 0.6, qr[0])
circuit.u3(0.5, 0.6, 0.7, qr[0])
circuit.cx(qr[0], qr[1])
circuit.cy(qr[0], qr[1])
circuit.cz(qr[0], qr[1])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
self.assertEqual(self.pset["commutation_set"]["qr[0]"],
[[1], [5], [6], [7], [8, 9, 10, 11], [12], [13], [14],
[15], [16], [2]])
self.assertEqual(self.pset["commutation_set"]["qr[1]"],
[[3], [14], [15], [16], [4]])
def test_non_commutative_circuit(self):
"""A simple circuit where no gates commute
qr0:---[H]---
qr1:---[H]---
qr2:---[H]---
"""
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.h(qr)
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
self.assertEqual(self.pset["commutation_set"]["qr[0]"],
[[1], [7], [2]])
self.assertEqual(self.pset["commutation_set"]["qr[1]"],
[[3], [8], [4]])
self.assertEqual(self.pset["commutation_set"]["qr[2]"],
[[5], [9], [6]])
def test_non_commutative_circuit_2(self):
"""A simple circuit where no gates commute
qr0:----.-------------
|
qr1:---(+)------.-----
|
qr2:---[H]-----(+)----
"""
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.h(qr[2])
circuit.cx(qr[1], qr[2])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
self.assertEqual(self.pset["commutation_set"]["qr[0]"],
[[1], [7], [2]])
self.assertEqual(self.pset["commutation_set"]["qr[1]"],
[[3], [7], [9], [4]])
self.assertEqual(self.pset["commutation_set"]["qr[2]"],
[[5], [8], [9], [6]])
def test_commutative_circuit(self):
"""A simple circuit where two CNOTs commute
qr0:----.------------
|
qr1:---(+)-----(+)---
|
qr2:---[H]------.----
"""
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.h(qr[2])
circuit.cx(qr[2], qr[1])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
self.assertEqual(self.pset["commutation_set"]["qr[0]"],
[[1], [7], [2]])
self.assertEqual(self.pset["commutation_set"]["qr[1]"],
[[3], [7, 9], [4]])
self.assertEqual(self.pset["commutation_set"]["qr[2]"],
[[5], [8], [9], [6]])
def test_commutative_circuit_2(self):
"""A simple circuit where a CNOT and a Z gate commute,
and a CNOT and a CNOT commute
qr0:----.-----[Z]-----
|
qr1:---(+)----(+)----
|
qr2:---[H]-----.----
"""
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.z(qr[0])
circuit.h(qr[2])
circuit.cx(qr[2], qr[1])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
self.assertEqual(self.pset["commutation_set"]["qr[0]"],
[[1], [7, 8], [2]])
self.assertEqual(self.pset["commutation_set"]["qr[1]"],
[[3], [7, 10], [4]])
self.assertEqual(self.pset["commutation_set"]["qr[2]"],
[[5], [9], [10], [6]])
def test_commutative_circuit_3(self):
"""A simple circuit where multiple gates commute
qr0:----.-----[Z]-----.----[z]-----
| |
qr1:---(+)----(+)----(+)----.------
| |
qr2:---[H]-----.-----[x]---(+)-----
"""
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.h(qr[2])
circuit.z(qr[0])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[0], qr[1])
circuit.x(qr[2])
circuit.z(qr[0])
circuit.cx(qr[1], qr[2])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
self.assertEqual(self.pset["commutation_set"]["qr[0]"],
[[1], [7, 9, 11, 13], [2]])
self.assertEqual(self.pset["commutation_set"]["qr[1]"],
[[3], [7, 10, 11], [14], [4]])
self.assertEqual(self.pset["commutation_set"]["qr[2]"],
[[5], [8], [10], [12, 14], [6]])
def test_jordan_wigner_type_circuit(self):
"""A Jordan-Wigner type circuit where consecutive CNOTs commute
qr0:----.-------------------------------------------------------------.----
| |
qr1:---(+)----.-------------------------------------------------.----(+)---
| |
qr2:---------(+)----.-------------------------------------.----(+)---------
| |
qr3:---------------(+)----.-------------------------.----(+)---------------
| |
qr4:---------------------(+)----.-------------.----(+)---------------------
| |
qr5:---------------------------(+)----[z]----(+)---------------------------
"""
qr = QuantumRegister(6, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[4], qr[5])
circuit.z(qr[5])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[0], qr[1])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
self.assertEqual(self.pset["commutation_set"]["qr[0]"],
[[1], [13, 23], [2]])
self.assertEqual(self.pset["commutation_set"]["qr[1]"],
[[3], [13], [14, 22], [23], [4]])
self.assertEqual(self.pset["commutation_set"]["qr[2]"],
[[5], [14], [15, 21], [22], [6]])
self.assertEqual(self.pset["commutation_set"]["qr[3]"],
[[7], [15], [16, 20], [21], [8]])
self.assertEqual(self.pset["commutation_set"]["qr[4]"],
[[9], [16], [17, 19], [20], [10]])
self.assertEqual(self.pset["commutation_set"]["qr[5]"],
[[11], [17], [18], [19], [12]])
def test_all_commute_circuit(self):
"""Test circuit with that all commute"""
qr = QuantumRegister(5, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[4], qr[3])
circuit.cx(qr[2], qr[3])
circuit.z(qr[0])
circuit.z(qr[4])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[4], qr[3])
circuit.cx(qr[2], qr[3])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
self.assertEqual(self.pset["commutation_set"]["qr[0]"],
[[1], [11, 15, 17], [2]])
self.assertEqual(self.pset["commutation_set"]["qr[1]"],
[[3], [11, 12, 17, 18], [4]])
self.assertEqual(self.pset["commutation_set"]["qr[2]"],
[[5], [12, 14, 18, 20], [6]])
self.assertEqual(self.pset["commutation_set"]["qr[3]"],
[[7], [13, 14, 19, 20], [8]])
self.assertEqual(self.pset["commutation_set"]["qr[4]"],
[[9], [13, 16, 19], [10]])
def setUp(self):
self.com_pass_ = CommutationAnalysis()
self.pass_ = CommutativeCancellation()
self.pset = self.pass_.property_set = PropertySet()
def __init__(self):
super().__init__()
self.requires.append(CommutationAnalysis())
self.preserves.append(CommutationAnalysis())
self.qreg_op = {}
self.node_order = {}
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import CommutationAnalysis, CommutationTransformation
from qiskit.transpiler import transpile
qr = QuantumRegister(5, 'qr')
circuit = QuantumCircuit(qr)
# Quantum Instantaneous Polynomial Time example
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[4], qr[3])
circuit.cx(qr[2], qr[3])
circuit.z(qr[0])
circuit.z(qr[4])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[4], qr[3])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[3], qr[2])
print(circuit.draw())
pm = PassManager()
pm.append([CommutationAnalysis(), CommutationTransformation()])
# TODO make it not needed to have a backend
backend_device = BasicAer.get_backend('qasm_simulator')
circuit = transpile(circuit, backend_device, pass_manager=pm)
print(circuit.draw())
# # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. from qiskit import QuantumCircuit from qiskit.transpiler import PassManager from qiskit.transpiler.passes import CommutationAnalysis, CommutativeCancellation circuit = QuantumCircuit(5) # Quantum Instantaneous Polynomial Time example circuit.cx(0, 1) circuit.cx(2, 1) circuit.cx(4, 3) circuit.cx(2, 3) circuit.z(0) circuit.z(4) circuit.cx(0, 1) circuit.cx(2, 1) circuit.cx(4, 3) circuit.cx(2, 3) circuit.cx(3, 2) print(circuit) pm = PassManager() pm.append([CommutationAnalysis(), CommutativeCancellation()]) new_circuit = pm.run(circuit) print(new_circuit)
def run_on_nam_benchmarks(fname):
f = open(fname, "w")
f.write(
"name, num gates before, t-count before, num gates after (A), t-count after (A), num gates after (B)\n"
)
for fname in os.listdir("nam-benchmarks"):
print("Processing %s..." % fname)
# Some of the benchmarks contain 'ccz' and 'ccx' gates. For consistency, we
# want to make sure Qiskit uses the same decomposition for these gates as VOQC.
# Our (hacky) solution for now is to make a copy of the benchmark that contains
# already-decomposed versions of ccx and ccz.
inqasm = open("nam-benchmarks/%s" % fname, "r")
tmp = open("copy.qasm", "w") # hardcoded filename
p_ccz = re.compile("ccz (.*), (.*), (.*);")
p_ccx = re.compile("ccx (.*), (.*), (.*);")
for line in inqasm:
m1 = p_ccx.match(line)
m2 = p_ccz.match(line)
if m1:
a = m1.group(1)
b = m1.group(2)
c = m1.group(3)
tmp.write("h %s;\n" % (c))
tmp.write("cx %s, %s;\n" % (b, c))
tmp.write("tdg %s;\n" % (c))
tmp.write("cx %s, %s;\n" % (a, c))
tmp.write("t %s;\n" % (c))
tmp.write("cx %s, %s;\n" % (b, c))
tmp.write("tdg %s;\n" % (c))
tmp.write("cx %s, %s;\n" % (a, c))
tmp.write("cx %s, %s;\n" % (a, b))
tmp.write("tdg %s;\n" % (b))
tmp.write("cx %s, %s;\n" % (a, b))
tmp.write("t %s;\n" % (a))
tmp.write("t %s;\n" % (b))
tmp.write("t %s;\n" % (c))
tmp.write("h %s;\n" % (c))
elif m2:
a = m2.group(1)
b = m2.group(2)
c = m2.group(3)
tmp.write("cx %s, %s;\n" % (b, c))
tmp.write("tdg %s;\n" % (c))
tmp.write("cx %s, %s;\n" % (a, c))
tmp.write("t %s;\n" % (c))
tmp.write("cx %s, %s;\n" % (b, c))
tmp.write("tdg %s;\n" % (c))
tmp.write("cx %s, %s;\n" % (a, c))
tmp.write("cx %s, %s;\n" % (a, b))
tmp.write("tdg %s;\n" % (b))
tmp.write("cx %s, %s;\n" % (a, b))
tmp.write("t %s;\n" % (a))
tmp.write("t %s;\n" % (b))
tmp.write("t %s;\n" % (c))
else:
tmp.write(line)
tmp.close()
circ = QuantumCircuit.from_qasm_file("copy.qasm")
num_gates_before = count(circ.count_ops())
# getting a t-count only makes sense for the current benchmarks, which only
# contain rotations by PI/4
t_count_before = 0
for inst, _, _ in circ.data:
if (inst.name == "t" or inst.name == "tdg"):
t_count_before += 1
print("\nORIGINAL: %d gates, %d T-gates" %
(num_gates_before, t_count_before))
# A
basis_gates = ['u1', 'h', 'x', 'cx']
_unroll = Unroller(basis_gates)
_depth_check = [Depth(), FixedPoint('depth')]
def _opt_control(property_set):
return not property_set['depth_fixed_point']
_opt = [Optimize1qGates(), CommutativeCancellation()]
pmA = PassManager()
pmA.append(_unroll)
pmA.append([CommutationAnalysis()])
pmA.append(_depth_check + _opt, do_while=_opt_control)
circA = pmA.run(circ)
num_gates_afterA = count(circA.count_ops())
t_count_afterA = 0
for inst, _, _ in circA.data:
if (inst.name == "u1"):
if (get_closest_multiple_of_pi(inst.params[0]) % 2 == 1):
t_count_afterA += 1
print("OPTIMIZED (A): %d gates, %d T-gates" %
(num_gates_afterA, t_count_afterA))
# B
basis_gates = ['u1', 'u2', 'u3', 'cx']
_unroll = Unroller(basis_gates)
_depth_check = [Depth(), FixedPoint('depth')]
def _opt_control(property_set):
return not property_set['depth_fixed_point']
_opt = [
Collect2qBlocks(),
ConsolidateBlocks(),
Unroller(basis_gates), # unroll unitaries
Optimize1qGates(),
CommutativeCancellation()
]
pmB = PassManager()
pmB.append(_unroll)
pmB.append(_depth_check + _opt, do_while=_opt_control)
circB = pmB.run(circ)
num_gates_afterB = count(circB.count_ops())
# not sure how to get the t-gate count for the {u1, u2, u3, CX} gate set
print("OPTIMIZED (B): %d gates\n" % (num_gates_afterB))
f.write("%s,%d,%d,%d,%d,%d\n" %
(fname, num_gates_before, t_count_before, num_gates_afterA,
t_count_afterA, num_gates_afterB))
f.close()
# This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory # of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. # # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. from qiskit import * from qiskit.transpiler import PassManager from qiskit.transpiler.passes import CommutationAnalysis, CommutativeCancellation, MatchZZInteraction#, CommutativeMatchZZInteraction circuit = QuantumCircuit(4) # Quantum Instantaneous Polynomial Time example circuit.cx(0, 1) circuit.z(1) circuit.cx(0, 1) circuit.cx(0, 2) circuit.rz(0.5, 2) circuit.rz(0.3, 0) circuit.cx(0, 3) circuit.cx(0, 2) print(circuit) pm = PassManager() pm.append([CommutationAnalysis(), MatchZZInteraction()]) new_circuit=pm.run(circuit) print(new_circuit)
