mirror of https://github.com/Qiskit/qiskit.git
Tools auto-linted.
This commit is contained in:
Jesús Pérez
parent
b0ae982702
commit
34c35a4d13
2
Makefile
2
Makefile
|
|
@ -9,7 +9,7 @@ env-dev:
|
|||
bash -c "source activate QISKitenv;pip install pylint matplotlib"
|
||||
|
||||
lint:
|
||||
bash -c "source activate QISKitenv;pylint qiskit test tools tutorial"
|
||||
bash -c "source activate QISKitenv;pylint test"
|
||||
|
||||
test:
|
||||
bash -c "source activate QISKitenv;python test/QISKit-tests.py"
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ def destroy(dim):
|
|||
a = np.zeros((dim, dim), dtype=complex)
|
||||
for jj in range(dim):
|
||||
for kk in range(dim):
|
||||
if kk-jj == 1:
|
||||
if kk - jj == 1:
|
||||
a[jj, kk] = np.sqrt(jj + 1)
|
||||
return a
|
||||
|
||||
|
|
@ -31,7 +31,7 @@ def operator_qi(gate, qubit, number_of_qubits):
|
|||
number_of_qubits is the number of qubits in the system
|
||||
returns a complex numpy array
|
||||
"""
|
||||
return np.kron(np.identity(2**(number_of_qubits-qubit-1), dtype=complex),
|
||||
return np.kron(np.identity(2**(number_of_qubits - qubit - 1), dtype=complex),
|
||||
np.kron(gate, np.identity(2**(qubit), dtype=complex)))
|
||||
|
||||
|
||||
|
|
@ -44,7 +44,8 @@ def operator_qij(gate, qubit_1, qubit_2, number_of_qubits):
|
|||
number_of_qubits is the number of qubits in the system
|
||||
returns a complex numpy array
|
||||
"""
|
||||
temp_1 = np.kron(np.identity(2**(number_of_qubits-2), dtype=complex), gate)
|
||||
temp_1 = np.kron(np.identity(
|
||||
2**(number_of_qubits - 2), dtype=complex), gate)
|
||||
temp_2 = np.identity(2**(number_of_qubits), dtype=complex)
|
||||
for ii in range(2**number_of_qubits):
|
||||
iistring = bin(ii)[2:]
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
|
||||
import random
|
||||
import numpy as np
|
||||
|
||||
|
||||
class Pauli:
|
||||
"""A simple class representing Pauli Operators
|
||||
The Form is P = (-i)^dot(v,w) Z^v X^w
|
||||
|
|
@ -22,11 +24,13 @@ class Pauli:
|
|||
|
||||
Multiplication is P1*P2 = (-i)^dot(v1+v2,w1+w2) Z^(v1+v2) X^(w1+w2) where sums are mod 2
|
||||
"""
|
||||
|
||||
def __init__(self, v, w):
|
||||
""" makes the Pauli class """
|
||||
self.v = v
|
||||
self.w = w
|
||||
self.numberofqubits = len(v)
|
||||
|
||||
def __str__(self):
|
||||
""" Outputs the pauli as first row v and second row w"""
|
||||
stemp = '\nv = '
|
||||
|
|
@ -36,16 +40,18 @@ class Pauli:
|
|||
for j in self.w:
|
||||
stemp += str(j) + '\t'
|
||||
return stemp + '\n'
|
||||
|
||||
def __mul__(self, other):
|
||||
""" Multiples two Paulis """
|
||||
if self.numberofqubits != other.numberofqubits:
|
||||
print('Paulis cannot be multipled - different number of qubits')
|
||||
vnew = (self.v + other.v) % 2
|
||||
wnew = (self.w + other.w) % 2
|
||||
#print vnew
|
||||
#print wnew
|
||||
# print vnew
|
||||
# print wnew
|
||||
paulinew = Pauli(vnew, wnew)
|
||||
return paulinew
|
||||
|
||||
def toLabel(self):
|
||||
""" prints out the labels in X, Y, Z format"""
|
||||
plabel = ''
|
||||
|
|
@ -59,35 +65,38 @@ class Pauli:
|
|||
elif self.v[jindex] == 1 and self.w[jindex] == 0:
|
||||
plabel += 'Z'
|
||||
return plabel
|
||||
|
||||
def toQASM(self, qubits):
|
||||
""" prints out the qasm format for the Pauli"""
|
||||
if len(qubits) == self.numberofqubits:
|
||||
qasmlabel = ''
|
||||
for jindex in qubits:
|
||||
if self.v[jindex] == 0 and self.w[jindex] == 0:
|
||||
qasmlabel += 'id q[' + str(jindex) + '];\n'# identity
|
||||
qasmlabel += 'id q[' + str(jindex) + '];\n' # identity
|
||||
elif self.v[jindex] == 0 and self.w[jindex] == 1:
|
||||
qasmlabel += 'u3(-pi,0,-pi) q[' + str(jindex) + '];\n'# x
|
||||
qasmlabel += 'u3(-pi,0,-pi) q[' + str(jindex) + '];\n' # x
|
||||
elif self.v[jindex] == 1 and self.w[jindex] == 1:
|
||||
qasmlabel += 'u3(-pi,0,2*pi) q[' + str(jindex) + '];\n'# y
|
||||
# y
|
||||
qasmlabel += 'u3(-pi,0,2*pi) q[' + str(jindex) + '];\n'
|
||||
elif self.v[jindex] == 1 and self.w[jindex] == 0:
|
||||
qasmlabel += 'u1(pi) q[' + str(jindex) + '];\n'# z
|
||||
qasmlabel += 'u1(pi) q[' + str(jindex) + '];\n' # z
|
||||
qasmlabel += 'barrier q;\n'
|
||||
return qasmlabel
|
||||
else:
|
||||
print('the qubit vector did match the pauli')
|
||||
return -1
|
||||
|
||||
def to_matrix(self):
|
||||
""" converts pauli to a matrix representation"""
|
||||
X = np.array([[0, 1], [1, 0]], dtype=complex)
|
||||
Z = np.array([[1, 0], [0, -1]], dtype=complex)
|
||||
I = np.array([[1, 0], [0, 1]], dtype=complex)
|
||||
Xtemp = 1
|
||||
#print self.numberofqubits
|
||||
# print self.numberofqubits
|
||||
for k in range(self.numberofqubits):
|
||||
#print k
|
||||
#print self.v[k]
|
||||
#print self.w[k]
|
||||
# print k
|
||||
# print self.v[k]
|
||||
# print self.w[k]
|
||||
if self.v[k] == 0:
|
||||
tempz = I
|
||||
elif self.v[k] == 1:
|
||||
|
|
@ -102,23 +111,30 @@ class Pauli:
|
|||
print('the x string is not of the form 0 and 1')
|
||||
ope = np.dot(tempz, tempx)
|
||||
Xtemp = np.kron(Xtemp, ope)
|
||||
#print Xtemp
|
||||
paulimat = (-1j)**np.dot(self.v, self.w)*Xtemp
|
||||
#print paulimat
|
||||
# print Xtemp
|
||||
paulimat = (-1j)**np.dot(self.v, self.w) * Xtemp
|
||||
# print paulimat
|
||||
return paulimat
|
||||
|
||||
|
||||
def random_pauli(numberofqubits):
|
||||
'''This function returns a random Pauli on numberofqubits
|
||||
'''
|
||||
v = np.array(list(bin(random.getrandbits(numberofqubits))[2:].zfill(numberofqubits))).astype(np.int)
|
||||
w = np.array(list(bin(random.getrandbits(numberofqubits))[2:].zfill(numberofqubits))).astype(np.int)
|
||||
v = np.array(list(bin(random.getrandbits(numberofqubits))
|
||||
[2:].zfill(numberofqubits))).astype(np.int)
|
||||
w = np.array(list(bin(random.getrandbits(numberofqubits))
|
||||
[2:].zfill(numberofqubits))).astype(np.int)
|
||||
return Pauli(v, w)
|
||||
|
||||
|
||||
def InversePauli(other):
|
||||
'''This function returns the inverse of a pauli. This is honestly a trival function but to make sure that it is consistent with the clifford benchmarking
|
||||
'''
|
||||
v = other.v
|
||||
w = other.w
|
||||
return Pauli(v, w)
|
||||
|
||||
|
||||
def pauli_group(numberofqubits, case=0):
|
||||
''' Returns the Pauli group -- 4^n elements where the phases have been removed.
|
||||
case 0 is by ordering by Pauli weights and
|
||||
|
|
@ -132,29 +148,31 @@ def pauli_group(numberofqubits, case=0):
|
|||
if case == 0:
|
||||
tmp = PauliGroup(numberofqubits, case=1)
|
||||
# sort on the weight of the Pauli operator
|
||||
return sorted(tmp, key=lambda x: -np.count_nonzero(np.array(x.toLabel(), 'c') == b'I'))
|
||||
return sorted(tmp, key=lambda x: -
|
||||
np.count_nonzero(np.array(x.toLabel(), 'c') == b'I'))
|
||||
|
||||
elif case == 1:
|
||||
#the pauli set is in tensor order II IX IY IZ XI ...
|
||||
# the pauli set is in tensor order II IX IY IZ XI ...
|
||||
for kindex in range(4**numberofqubits):
|
||||
v = np.zeros(numberofqubits)
|
||||
w = np.zeros(numberofqubits)
|
||||
#looping over all the qubits
|
||||
# looping over all the qubits
|
||||
for jindex in range(numberofqubits):
|
||||
#making the pauli for each kindex i fill it in from the end first
|
||||
element = int((kindex)/(4**(jindex))) % 4
|
||||
# making the pauli for each kindex i fill it in from the
|
||||
# end first
|
||||
element = int((kindex) / (4**(jindex))) % 4
|
||||
if element == 0:
|
||||
v[numberofqubits-jindex-1] = 0
|
||||
w[numberofqubits-jindex-1] = 0
|
||||
v[numberofqubits - jindex - 1] = 0
|
||||
w[numberofqubits - jindex - 1] = 0
|
||||
elif element == 1:
|
||||
v[numberofqubits-jindex-1] = 0
|
||||
w[numberofqubits-jindex-1] = 1
|
||||
v[numberofqubits - jindex - 1] = 0
|
||||
w[numberofqubits - jindex - 1] = 1
|
||||
elif element == 2:
|
||||
v[numberofqubits-jindex-1] = 1
|
||||
w[numberofqubits-jindex-1] = 1
|
||||
v[numberofqubits - jindex - 1] = 1
|
||||
w[numberofqubits - jindex - 1] = 1
|
||||
elif element == 3:
|
||||
v[numberofqubits-jindex-1] = 1
|
||||
w[numberofqubits-jindex-1] = 0
|
||||
v[numberofqubits - jindex - 1] = 1
|
||||
w[numberofqubits - jindex - 1] = 0
|
||||
tempset.append(Pauli(v, w))
|
||||
return tempset
|
||||
else:
|
||||
|
|
|
|||
|
|
@ -26,28 +26,36 @@ def cost_classical(data, n, alpha, beta):
|
|||
observable = 0
|
||||
for j in range(len(key) - n, len(key)):
|
||||
if key[j] == '0':
|
||||
observable = observable + alpha[len(key)-1-j]
|
||||
observable = observable + alpha[len(key) - 1 - j]
|
||||
elif key[j] == '1':
|
||||
observable = observable - alpha[len(key)-1-j]
|
||||
observable = observable - alpha[len(key) - 1 - j]
|
||||
for i in range(j):
|
||||
if key[j] == '0' and key[i] == '0':
|
||||
observable = observable + beta[len(key)-1-i, len(key)-1-j]
|
||||
observable = observable + \
|
||||
beta[len(key) - 1 - i, len(key) - 1 - j]
|
||||
elif key[j] == '1' and key[i] == '1':
|
||||
observable = observable + beta[len(key)-1-i, len(key)-1-j]
|
||||
observable = observable + \
|
||||
beta[len(key) - 1 - i, len(key) - 1 - j]
|
||||
elif key[j] == '0' and key[i] == '1':
|
||||
observable = observable - beta[len(key)-1-i, len(key)-1-j]
|
||||
observable = observable - \
|
||||
beta[len(key) - 1 - i, len(key) - 1 - j]
|
||||
elif key[j] == '1' and key[i] == '0':
|
||||
observable = observable - beta[len(key)-1-i, len(key)-1-j]
|
||||
for i in range(j+1, len(key)):
|
||||
observable = observable - \
|
||||
beta[len(key) - 1 - i, len(key) - 1 - j]
|
||||
for i in range(j + 1, len(key)):
|
||||
if key[j] == '0' and key[i] == '0':
|
||||
observable = observable + beta[len(key)-1-i, len(key)-1-j]
|
||||
observable = observable + \
|
||||
beta[len(key) - 1 - i, len(key) - 1 - j]
|
||||
elif key[j] == '1' and key[i] == '1':
|
||||
observable = observable + beta[len(key)-1-i, len(key)-1-j]
|
||||
observable = observable + \
|
||||
beta[len(key) - 1 - i, len(key) - 1 - j]
|
||||
elif key[j] == '0' and key[i] == '1':
|
||||
observable = observable - beta[len(key)-1-i, len(key)-1-j]
|
||||
observable = observable - \
|
||||
beta[len(key) - 1 - i, len(key) - 1 - j]
|
||||
elif key[j] == '1' and key[i] == '0':
|
||||
observable = observable - beta[len(key)-1-i, len(key)-1-j]
|
||||
temp += data[key]*observable/tot
|
||||
observable = observable - \
|
||||
beta[len(key) - 1 - i, len(key) - 1 - j]
|
||||
temp += data[key] * observable / tot
|
||||
return temp
|
||||
|
||||
|
||||
|
|
@ -74,7 +82,7 @@ def trial_funtion_optimization(n, m, theta, entangler_map):
|
|||
for j in entangler_map[node]:
|
||||
trial_circuit.cz(q[node], q[j])
|
||||
for j in range(n):
|
||||
trial_circuit.ry(theta[n*i+j], q[j])
|
||||
trial_circuit.ry(theta[n * i + j], q[j])
|
||||
trial_circuit.barrier(q)
|
||||
for j in range(n):
|
||||
trial_circuit.measure(q[j], c[j])
|
||||
|
|
|
|||
|
|
@ -9,11 +9,11 @@ print(operator_qi(gate, 0, 3))
|
|||
print(operator_qi(gate, 1, 3))
|
||||
print(operator_qi(gate, 2, 3))
|
||||
|
||||
<<<<<<< Updated upstream
|
||||
<< << << < Updated upstream
|
||||
cnot = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
|
||||
print(" --------------------")
|
||||
print(operator_qij(gate, 0, 1, 2))
|
||||
=======
|
||||
== == == =
|
||||
cnot = np.array([[1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0]])
|
||||
print(" --------------------")
|
||||
print(operator_qij(cnot, 0, 1, 2))
|
||||
|
|
@ -22,4 +22,4 @@ print(operator_qij(cnot, 1, 0, 2))
|
|||
|
||||
print(operator_qij(cnot, 0, 1, 3))
|
||||
print(operator_qij(cnot, 1, 2, 3))
|
||||
>>>>>>> Stashed changes
|
||||
>>>>>> > Stashed changes
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ entangler_map = {0: [2], 1: [2], 3: [2], 4: [2]}
|
|||
|
||||
m = 1
|
||||
n = 6
|
||||
theta = np.zeros(m*n)
|
||||
theta = np.zeros(m * n)
|
||||
trial_circuit = trial_funtion_optimization(n, m, theta, entangler_map)
|
||||
|
||||
program = [trial_circuit]
|
||||
|
|
|
|||
Loading…
Reference in New Issue