def polyPauliRotation(nb_vars_max=15):
from unqomp.examples.polynomialpaulirot import makesQiskitPolyPauliRot
from unqomp.examples.polynomialpaulirot import makesPolyPauliRot
from qiskit.circuit.library import PolynomialPauliRotations
#from unqomp.examples.mcx import makeQiskitMCRY
nb_vars_t4 = []
nb_qb_qi4 = []
nb_qb_mi4 = []
nb_gates_qi4 = []
nb_gates_mi4 = []
nb_qb_bq4 = []
nb_gates_bq4 = []
coeffs = [1 for i in range(nb_vars_max)]
for nb_vars in range(3, nb_vars_max):
circuit1 = makesPolyPauliRot(
7, coeffs[:nb_vars]).circuitWithUncomputation()
qiskitMCX = makesQiskitPolyPauliRot(7, coeffs[:nb_vars])
buggyQi = PolynomialPauliRotations(7, coeffs[:nb_vars])
nb_vars_t4.append(nb_vars)
#qiskit
nb_qb_qi4.append(qiskitMCX.num_qubits)
nb_gates_qi4.append(qiskitMCX.decompose().decompose().decompose().
decompose().decompose().count_ops())
#bad qiskit
nb_qb_bq4.append(buggyQi.num_qubits)
nb_gates_bq4.append(buggyQi.decompose().decompose().decompose().
decompose().decompose().count_ops())
#mine
nb_qb_mi4.append(circuit1.num_qubits)
nb_gates_mi4.append(circuit1.decompose().decompose().decompose().
decompose().decompose().count_ops())
with open('evaluation/plot_values/polynomialpaulirotation.csv',
'w') as f:
sys.stdout = f # Change the standard output to the file we created.
print(
"input size; n_qb Qiskit without regression bug; n_gates Qiskit without regression bug; n_cx_gates Qiskitwithout regression bug; n_qb Unqomp; n_gates Unqomp ; n_cx_gates Uncomp; n_qb Qiskit with regression bug; n_gates Qiskit with regression bug ; n_cx_gates Qiskit with regression bug"
)
for i in range(len(nb_vars_t4)):
print(nb_vars_t4[i], ";", nb_qb_qi4[i], ";",
nb_gates_qi4[i]['u3'] + nb_gates_qi4[i]['cx'], ";",
nb_gates_qi4[i]['cx'], ";", nb_qb_mi4[i], ";",
nb_gates_mi4[i]['u3'] + nb_gates_mi4[i]['cx'], ";",
nb_gates_mi4[i]['cx'], ";", nb_qb_bq4[i], ";",
nb_gates_bq4[i]['u3'] + nb_gates_bq4[i]['cx'], ";",
nb_gates_bq4[i]['cx'])
sys.stdout = original_stdout # Reset the standard output to its original value
def test_polynomial_function(self, coeffs, num_state_qubits):
"""Test the polynomial rotation."""
def poly(x):
res = sum(coeff * x**i for i, coeff in enumerate(coeffs))
return res
polynome = PolynomialPauliRotations(num_state_qubits, [2 * coeff for coeff in coeffs])
self.assertFunctionIsCorrect(polynome, poly)
def ppr(relative_numbers):
from unqomp.examples.polynomialpaulirot import makesPolyPauliRot, makesQiskitPolyPauliRot
from qiskit.circuit.library import PolynomialPauliRotations
coeffs = [1,2,3,4,5,4,1,2,3,4,5]
n = 8
circuit1 = makesPolyPauliRot(8, coeffs).circuitWithUncomputation()
qcirc = PolynomialPauliRotations(num_state_qubits=8, coeffs=coeffs)
print('PolynomialPauliR with regression bug ; ', end = '')
#qiskit
nb_qb_qi = qcirc.num_qubits
nb_gates_qi = qcirc.decompose().decompose().decompose().decompose().decompose().count_ops()
if not relative_numbers:
print(str(nb_qb_qi) + ' ; ' + str(nb_gates_qi['cx'] + nb_gates_qi['u3']) + ' ; ' + str(nb_gates_qi['cx']) + ' ; ', end = '')
#qiskit++
nb_qb_mi = circuit1.num_qubits
nb_gates_mi = circuit1.decompose().decompose().decompose().decompose().decompose().count_ops()
if not relative_numbers:
print(str(nb_qb_mi) + ' ; ' + str(nb_gates_mi['cx'] + nb_gates_mi['u3']) + ' ; ' + str(nb_gates_mi['cx']))
if relative_numbers:
print_relative_vals(nb_qb_qi, nb_gates_qi['cx'], nb_gates_qi['u3'], nb_qb_mi, nb_gates_mi['cx'], nb_gates_mi['u3'])
#qiskit with bug fixed
qiskitMCX = makesQiskitPolyPauliRot(n, coeffs)
nb_qb_qi = qiskitMCX.num_qubits
nb_gates_qi = qiskitMCX.decompose().decompose().decompose().decompose().decompose().count_ops()
print('PolynomialPauliR *, regression bug fixed ; ', end = '')
if not relative_numbers:
print(str(nb_qb_qi) + ' ; ' + str(nb_gates_qi['cx'] + nb_gates_qi['u3']) + ' ; ' + str(nb_gates_qi['cx']) + str(' ; '), end = '')
print(str(nb_qb_mi) + ' ; ' + str(nb_gates_mi['cx'] + nb_gates_mi['u3']) + ' ; ' + str(nb_gates_mi['cx']))
else:
print_relative_vals(nb_qb_qi, nb_gates_qi['cx'], nb_gates_qi['u3'], nb_qb_mi, nb_gates_mi['cx'], nb_gates_mi['u3'])
def build(self, qc, q, q_target, q_ancillas=None, reverse=0):
r"""Build the circuit.
Args:
qc (QuantumCircuit): quantum circuit
q (list): list of qubits (has to be same length as self.num_state_qubits)
q_target (Qubit): qubit to be rotated. The algorithm is successful when
this qubit is in the \|1> state
q_ancillas (list): list of ancilla qubits (or None if none needed)
reverse (int): if 1, apply with reversed list of qubits
(i.e. q_n as q_0, q_n-1 as q_1, etc).
"""
instr = PolynomialPauliRotations(
num_state_qubits=self.num_state_qubits,
coeffs=self.px,
basis=self.basis,
reverse=reverse).to_instruction()
# pylint:disable=unnecessary-comprehension
qr = [qi for qi in q] + [q_target]
if q_ancillas:
qr += [qi for qi in q_ancillas[:self.required_ancillas()]]
qc.append(instr, qr)
def test_polynomial_rotations_mutability(self):
"""Test the mutability of the linear rotations circuit."""
polynomial_rotations = PolynomialPauliRotations()
with self.subTest(msg='missing number of state qubits'):
with self.assertRaises(AttributeError): # no state qubits set
print(polynomial_rotations.draw())
with self.subTest(msg='default setup, just setting number of state qubits'):
polynomial_rotations.num_state_qubits = 2
self.assertFunctionIsCorrect(polynomial_rotations, lambda x: x / 2)
with self.subTest(msg='setting non-default values'):
polynomial_rotations.coeffs = [0, 1.2 * 2, 0.4 * 2]
self.assertFunctionIsCorrect(polynomial_rotations, lambda x: 1.2 * x + 0.4 * x ** 2)
with self.subTest(msg='changing of all values'):
polynomial_rotations.num_state_qubits = 4
polynomial_rotations.coeffs = [1 * 2, 0, 0, -0.5 * 2]
self.assertFunctionIsCorrect(polynomial_rotations, lambda x: 1 - 0.5 * x**3)
