def run_grover(eng, n, Ox):
# start in uniform superposition
x = eng.allocate_qureg(n)
All(H) | x
# the auxiliary indicator qbit, prepare it as '|->'
y = eng.allocate_qubit()
X | y
H | y
# number of iterations we have to run:
ITER = int(math.pi / 4.0 * math.sqrt(1 << n))
with Loop(eng, ITER):
# oracle adds a (-1)-phase to the solution(s)
Ox(eng, x, y)
# reflection across uniform superposition
with Compute(eng):
All(H) | x
All(X) | x
with Control(eng, x[:-1]): # Z == H-CNOT(x[-1])-H ??
Z | x[-1]
Uncompute(eng)
All(Measure) | x
Measure | y
eng.flush()
return ''.join([str(int(q)) for q in x])
def _decompose_QPE(cmd): # pylint: disable=invalid-name
"""Decompose the Quantum Phase Estimation gate."""
eng = cmd.engine
# Ancillas is the first qubit/qureg. System-qubit is the second qubit/qureg
qpe_ancillas = cmd.qubits[0]
system_qubits = cmd.qubits[1]
# Hadamard on the ancillas
Tensor(H) | qpe_ancillas
# The Unitary Operator
unitary = cmd.gate.unitary
# Control U on the system_qubits
if callable(unitary):
# If U is a function
for i, ancilla in enumerate(qpe_ancillas):
with Control(eng, ancilla):
unitary(system_qubits, time=2**i)
else:
for i, ancilla in enumerate(qpe_ancillas):
ipower = int(2**i)
with Loop(eng, ipower):
with Control(eng, ancilla):
unitary | system_qubits
# Inverse QFT on the ancillas
get_inverse(QFT) | qpe_ancillas
def ExecuteGrover(engine, n, oracle):
x = engine.allocate_qureg(n)
All(H) | x
num_it = int(math.pi/4.*math.sqrt(1 << n))
oracle_out = engine.allocate_qubit()
X | oracle_out
H | oracle_out
with Loop(engine, num_it):
oracle(engine, x, oracle_out)
with Compute(engine):
All(H) | x
All(X) | x
with Control(engine, x[0:-1]):
Z | x[-1]
Uncompute(engine)
All(Measure) | x
Measure | oracle_out
engine.flush()
return [int(qubit) for qubit in x]
def run_phase_estimation(eng, U, state, m, n):
"""
Phase estimation algorithm on unitary U.
Args:
eng (MainEngine): Main compiler engine to run the phase_estimation algorithm
U (np.matrix): the unitary that is to be estimated
state (qureg): the input state, which has the form |psi> otimes |0>.
State is composed of two parts:
1. The first n qubits are the input state |psi>, which is commonly
chosen to be the eigenstate of U
2. The last n qubits are initialized to |0>, which is used to
store the binary digits of the estimated phase
m (int): number of qubits for input state psi
n (int): number of qubits used to store the phase to given precision
"""
# The beginning index for the phase qubits will have an offset
OFFSET = m
# Phase 1. performs the controlled U^{2^j} operations
for k in range(n):
H | state[OFFSET + k]
with Control(eng, state[OFFSET + k]):
# number of loops required to perfrom the controlled U^{2^j} operation
num = int(math.pow(2, k))
# use the buildin loop
with Loop(eng, num):
U | state[:OFFSET]
# Phase 2. performs the inverse QFT operation
# Step 2.1 swap the qubits
for k in range(int(math.floor(n / 2))):
Swap | (state[OFFSET + k], state[OFFSET + n - k - 1])
# Step 2.2 perfrom the original inverse QFT
get_inverse(QFT) | state[OFFSET:]
def _decompose_QPE(cmd):
""" Decompose the Quantum Phase Estimation gate. """
eng = cmd.engine
# Ancillas is the first qubit/qureg. System-qubit is the second qubit/qureg
qpe_ancillas = cmd.qubits[0]
system_qubits = cmd.qubits[1]
# Hadamard on the ancillas
Tensor(H) | qpe_ancillas
# The Unitary Operator
U = cmd.gate.unitary
# Control U on the system_qubits
if (callable(U)):
# If U is a function
for i in range(len(qpe_ancillas)):
with Control(eng, qpe_ancillas[i]):
U(system_qubits, time=2**i)
else:
for i in range(len(qpe_ancillas)):
ipower = int(2**i)
with Loop(eng, ipower):
with Control(eng, qpe_ancillas[i]):
U | system_qubits
# Inverse QFT on the ancillas
get_inverse(QFT) | qpe_ancillas
def quanutm_phase_estimation(eng):
All(H) | phase_reg
with Control(eng, phase_reg[0]):
run_qnn(eng)
with Control(eng, phase_reg[1]):
with Loop(eng, 2):
run_qnn(eng)
with Control(eng, phase_reg[2]):
with Loop(eng, 4):
run_qnn(eng)
Swap | (phase_reg[0], phase_reg[2])
get_inverse(QFT) | phase_reg
def test_complex_aa():
rule_set = DecompositionRuleSet(modules=[aa])
eng = MainEngine(
backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
],
)
system_qubits = eng.allocate_qureg(6)
# Prepare the control qubit in the |-> state
control = eng.allocate_qubit()
X | control
H | control
# Creates the initial state form the Algorithm
complex_algorithm(eng, system_qubits)
# Get the probabilty of getting the marked state before the AA
# to calculate the number of iterations
eng.flush()
prob000000 = eng.backend.get_probability('000000', system_qubits)
prob111111 = eng.backend.get_probability('111111', system_qubits)
total_amp_before = math.sqrt(prob000000 + prob111111)
theta_before = math.asin(total_amp_before)
# Apply Quantum Amplitude Amplification the correct number of times
# Theta is calculated previously using get_probability
# We calculate also the theoretical final probability
# of getting the good state
num_it = int(math.pi / (4.0 * theta_before) + 1)
theoretical_prob = math.sin((2 * num_it + 1.0) * theta_before)**2
with Loop(eng, num_it):
QAA(complex_algorithm, complex_oracle) | (system_qubits, control)
# Get the probabilty of getting the marked state after the AA
# to compare with the theoretical probability after the AA
eng.flush()
prob000000 = eng.backend.get_probability('000000', system_qubits)
prob111111 = eng.backend.get_probability('111111', system_qubits)
total_prob_after = prob000000 + prob111111
All(Measure) | system_qubits
H | control
Measure | control
eng.flush()
assert total_prob_after == pytest.approx(
theoretical_prob, abs=1e-2
), "The obtained probability is less than expected %f vs. %f" % (
total_prob_after,
theoretical_prob,
)
def run_grover(eng, n, oracle):
"""
Runs Grover's algorithm on n qubit using the provided quantum oracle.
Args:
eng (MainEngine): Main compiler engine to run Grover on.
n (int): Number of bits in the solution.
oracle (function): Function accepting the engine, an n-qubit register,
and an output qubit which is flipped by the oracle for the correct
bit string.
Returns:
solution (list<int>): Solution bit-string.
"""
x = eng.allocate_qureg(n)
# start in uniform superposition
All(H) | x
# number of iterations we have to run:
num_it = int(math.pi / 4. * math.sqrt(1 << n))
print("Number of iterations we have to run: {}".format(num_it))
# prepare the oracle output qubit (the one that is flipped to indicate the
# solution. start in state 1/sqrt(2) * (|0> - |1>) s.t. a bit-flip turns
# into a (-1)-phase.
oracle_out = eng.allocate_qubit()
X | oracle_out
H | oracle_out
# run num_it iterations
with Loop(eng, num_it):
# oracle adds a (-1)-phase to the solution
oracle(eng, x, oracle_out)
# reflection across uniform superposition
with Compute(eng):
All(H) | x
All(X) | x
with Control(eng, x[0:-1]):
Z | x[-1]
Uncompute(eng)
All(Ph(math.pi / n)) | x
All(Measure) | x
Measure | oracle_out
eng.flush()
# return result
return [int(qubit) for qubit in x]
def oraculo(eng, x, ctrl):
with Compute(eng):
All(NOT) | x[1::2]
with Control(eng, x):
NOT | ctrl
Uncompute(eng)
return
n = 4 #numero de bits da estrutura a ser buscada
eng = MainEngine() #IBMBackend(True))
x = eng.allocate_qureg(n)
All(H) | x
ctrl = eng.allocate_qubit()
NOT | ctrl
H | ctrl
with Loop(eng, int(sqrt(2**n))): #ou for?
oraculo(eng, x, ctrl)
with Compute(eng):
All(H) | x
All(NOT) | x
with Control(eng, x[0:-1]):
Z | x[-1]
Uncompute(eng)
Measure | x
eng.flush()
print "Posicao encontrada:"
for i in range(n):
print int(x[i]),
def run_unknown_number_grover(eng, Dataset, oracle, threshold):
"""
Runs modified Grover's algorithm to find an element in a set larger than a
given value threshold, using the provided quantum oracle.
Args:
eng (MainEngine): Main compiler engine to run Grover on.
Dataset(list): The set to search for an element.
oracle (function): Function accepting the engine, an n-qubit register,
Dataset, the threshold, and an output qubit which is flipped by the
oracle for the correct bit string.
threshold: the threshold
Returns:
solution (list<int>): the location of Solution.
"""
N = len(Dataset)
n = int(math.ceil(math.log(N, 2)))
# number of iterations we have to run:
num_it = int(math.sqrt(N) * 9 / 4)
m = 1
landa = 6 / 5
# run num_it iterations
i = 0
while i < num_it:
random.seed(i)
j = random.randint(0, int(m))
x = eng.allocate_qureg(n)
# start in uniform superposition
All(H) | x
# prepare the oracle output qubit (the one that is flipped to indicate the
# solution. start in state 1/sqrt(2) * (|0> - |1>) s.t. a bit-flip turns
# into a (-1)-phase.
oracle_out = eng.allocate_qubit()
X | oracle_out
H | oracle_out
#run j iterations
with Loop(eng, j):
# oracle adds a (-1)-phase to the solution
oracle(eng, x, Dataset, threshold, oracle_out)
# reflection across uniform superposition
with Compute(eng):
All(H) | x
All(X) | x
with Control(eng, x[0:-1]):
Z | x[-1]
Uncompute(eng)
All(Measure) | x
Measure | oracle_out
#read the measure value
k = 0
xvalue = 0
while k < n:
xvalue = xvalue + int(x[k]) * (2**k)
k += 1
#compare to threshold
if Dataset[xvalue] > threshold:
return xvalue
m = m * landa
i = i + 1
#fail to find a solution (with high probability the solution doesnot exist)
return ("no answer")
output_reg = eng.allocate_qureg(3)
des_output = eng.allocate_qubit()
ancilla_qubit = eng.allocate_qubit()
ancilla2 = eng.allocate_qubit()
phase_reg = eng.allocate_qureg(3)
#initialize the ancilla and weight qubits
X | ancilla_qubit
H | ancilla_qubit
All(H) | layer1_weight_reg
All(H) | layer2_weight_reg
#run the training cycle, one should adjust the number of loops and run the whole program again to get results for different iterations
with Loop(eng, 2):
run_qbnn(eng)
H | ancilla_qubit
X | ancilla_qubit
All(Measure) | layer1_weight_reg
All(Measure) | layer2_weight_reg
eng.flush()
print(
"==========================================================================="
)
print("This is the QBNN demo")
print("The measured weight string is")
def SolveSudoku(eng, sudoku):
'''
Main function. Applies the grover algorithm one time to the qubits and returns the measured result. This result will be the solution of the sudoku with high probability.
Args:
eng (MainEngine): Main compiler engine the algorithm is being run on.
sudoku (string): Sudoku codified in a string.
'''
#Prepare a list of suitable groups and a list of slot names, identified by an 'x'.
groups = prep_sudoku(sudoku)
l_slots = sorted(
['x' + sudoku[i + 1] for i in range(len(sudoku)) if sudoku[i] == 'x'],
key=lambda n: int(n[1]))
#Prepare a dictionary that assigns two qubits to each slot.
qudic = {}
for slot in l_slots:
qudic[slot] = eng.allocate_qureg(2)
q_list = [q for key in qudic.keys() for q in qudic[key]]
#Compute the number of Grover iterations
num_it = int(math.pi / 4. * math.sqrt(1 << len(q_list)))
#Create one ancilla per group
ancillas = eng.allocate_qureg(len(groups))
#Prepare the oracle qubit, used to mark with a negative phase the sudoku solution
phase_q = eng.allocate_qubit()
X | phase_q
H | phase_q
#Start the superposition state
All(H) | q_list
with Loop(eng, num_it):
#Generate the oracles and connect them to their group ancilla.
with Compute(eng):
apply_oracles(eng, groups, qudic, ancillas)
#Most important step. Applies a toffoli gate between all the ancillas and the phase qubit. The state that fulfills the sudoku rules for all the groups, and thus solves the sudoku, will get a minus sign.
with Control(eng, ancillas):
X | phase_q
#Uncompute to clean the ancillas for future iterations
Uncompute(eng)
#Apply Grover diffusion operator
All(H) | q_list
All(X) | q_list
with Control(eng, q_list):
X | phase_q
All(X) | q_list
All(H) | q_list
#Measure everything
All(Measure) | q_list
All(Measure) | ancillas
Measure | phase_q
# Call the main engine to execute
eng.flush()
# Obtain the output. The measured result will be the solution with high probability.
results = ''
for q in q_list:
results = results + str(int(q))
#Translate the bit string to a list of numbers
xlist = bin_to_n(results)
return xlist
def run_exactgrover(eng, n, oracle, oracle_modified):
"""
Runs exact Grover's algorithm on n qubit using the two kind of provided
quantum oracles (oracle and oracle_modified).
This is an algorithm which can output solution with probability 1.
Args:
eng (MainEngine): Main compiler engine to run Grover on.
n (int): Number of bits in the solution.
oracle (function): Function accepting the engine, an n-qubit register,
and an output qubit which is flipped by the oracle for the correct
bit string.
Returns:
solution (list<int>): Solution bit-string.
"""
x = eng.allocate_qureg(n)
# start in uniform superposition
All(H) | x
# number of iterations we have to run:
num_it = int(math.pi/4.*math.sqrt(1 << n))
#phi is the parameter of modified oracle
#varphi is the parameter of reflection across uniform superposition
theta=math.asin(math.sqrt(1/(1 << n)))
phi=math.acos(-math.cos(2*theta)/(math.sin(2*theta)*math.tan((2*num_it+1)*theta)))
varphi=math.atan(1/(math.sin(2*theta)*math.sin(phi)*math.tan((2*num_it+1)*theta)))*2
# prepare the oracle output qubit (the one that is flipped to indicate the
# solution. start in state 1/sqrt(2) * (|0> - |1>) s.t. a bit-flip turns
# into a (-1)-phase.
oracle_out = eng.allocate_qubit()
X | oracle_out
H | oracle_out
# run num_it iterations
with Loop(eng, num_it):
# oracle adds a (-1)-phase to the solution
oracle(eng, x, oracle_out)
# reflection across uniform superposition
with Compute(eng):
All(H) | x
All(X) | x
with Control(eng, x[0:-1]):
Z | x[-1]
Uncompute(eng)
# prepare the oracle output qubit (the one that is flipped to indicate the
# solution. start in state |1> s.t. a bit-flip turns into a e^(i*phi)-phase.
H | oracle_out
oracle_modified(eng, x, oracle_out, phi)
with Compute(eng):
All(H) | x
All(X) | x
with Control(eng, x[0:-1]):
Rz(varphi) | x[-1]
Ph(varphi/2) | x[-1]
Uncompute(eng)
All(Measure) | x
Measure | oracle_out
eng.flush()
# return result
return [int(qubit) for qubit in x]
layer1_weight_reg = eng.allocate_qureg(3)
layer1_input_reg = eng.allocate_qureg(3)
output = eng.allocate_qubit()
des_output = eng.allocate_qubit()
ancilla_qubit2 = eng.allocate_qubit()
ancilla_qubit = eng.allocate_qubit()
phase_reg = eng.allocate_qureg(3)
X | ancilla_qubit
H | ancilla_qubit
All(H) | layer1_weight_reg
#run the training cycle, one should adjust the number of loops and run the whole program again to get results for different iterations
with Loop(eng, 1):
run_qbnn(eng)
H | ancilla_qubit
X | ancilla_qubit
eng.flush()
w1 = eng.backend.get_probability('000', layer1_weight_reg)
w2 = eng.backend.get_probability('001', layer1_weight_reg)
w3 = eng.backend.get_probability('010', layer1_weight_reg)
w4 = eng.backend.get_probability('011', layer1_weight_reg)
w5 = eng.backend.get_probability('100', layer1_weight_reg)
w6 = eng.backend.get_probability('101', layer1_weight_reg)
w7 = eng.backend.get_probability('110', layer1_weight_reg)
w8 = eng.backend.get_probability('111', layer1_weight_reg)
def tracjectory_simplify(eng,
Dataset,
targetPoint=5,
LSSEDthreshold=0,
simType="#"):
"""
The algorithm to find the maximum data in a dataset. The length of the input
dataset should be 2^x, x is a positive integer.
Args:
eng (MainEngine): Main compiler engine the algorithm is being run on.
Dataset(list): The dataset.
"""
d_1 = 9999999
N = len(Dataset)
qubitLength = N - 2
#all possible solutions since we fixed 2 xs
Nsolution = pow(2, N - 2)
memo = [[False for i in range(len(Dataset))] for j in range(len(Dataset))]
if (simType == "#"):
d_0 = ""
for i in range(0, ((len(Dataset) - 2) - (targetPoint - 2))):
d_0 += '0'
for i in range(0, targetPoint - 2):
d_0 += '1'
else:
d_0 = ""
for i in range(0, (len(Dataset) - 2)):
d_0 += '1'
[d_0LSSED, memo] = LSSEDSTATE(simTraj, '1' + d_0 + '1', memo)
d_1LSSED = d_0LSSED
# c=math.floor(1/2*pow(2,N-2))
c = 10
i = 0
for i in range(0, c):
#F = oracle
if (i == 0):
print("initial guessing is ", '1' + d_0 + '1')
print("with SED", d_0LSSED)
oracleFunction = oracleF(Dataset,
d_0LSSED,
simType=simType,
LSSEDthreshold=LSSEDthreshold,
targetPoint=targetPoint - 2,
memo=memo)
# print(F)
while (simType == "#" and (
(d_1 == 9999999) or
(d_1LSSED > d_0LSSED
or count_set_bitsString(d_1) != targetPoint - 2))) or (
simType == "SED" and
((d_1 == 9999999) or
((d_1LSSED > d_0LSSED and d_0LSSED != 0)
or LSSEDthreshold < d_1LSSED
or count_set_bitsString(d_1) > count_set_bitsString(d_0)))):
# print('d_1 > d_0')
# print(simType)
# print(d_0)
# print(d_1)
# print(d_1LSSED)
# print(d_0LSSED)
# print(count_set_bitsString(d_1))
# print(count_set_bitsString(d_0))
#map F to quantum state
#grover long
# sineBeta = np.sqrt(Msolution/Nsolution)
# beta = np.arcsin(sineBeta)
# # find J >= floor((np.pi-beta)/beta) + 1
# J = math.floor((math.pi-beta)/beta) + 1
# print("J",J)
# angleRotation = 2* np.arcsin( math.sin( np.pi/((4*J)+2) ) / sineBeta )
# print("angleRotation",angleRotation)
#phase rotation on qubits with J iteration
if (simType == "#"):
mapAllstate = [
oracleFunction(Int2binString(elem, qubitLength), d_1LSSED,
memo) for elem in range(pow(2, qubitLength))
]
else:
mapAllstate = [
oracleFunction(Int2binString(elem, qubitLength), d_1LSSED,
count_set_bitsString(d_0), LSSEDthreshold,
memo) for elem in range(pow(2, qubitLength))
]
# print(mapAllstate)
if (sum(mapAllstate) == 0):
d_1 = d_0
break
num = [0] * (qubitLength)
p = mapAllstate.index(1)
# print('p',p, LSSEDSTATE(Dataset,'1'+Int2binString(p,qubitLength)+'1') )
mapAllstate[p] = 0
mapAllstate[p] = 0
binaryIndex = 0
while p / 2 != 0:
num[binaryIndex] = p % 2
p = p // 2
binaryIndex += 1
# print("num",num)
# a1 = sum(elemnum)
# num1=num.copy()
# while a1>0:
# p = num1.index(1)
# a1 = a1-1
# num1[p]=0
# print("mark qubit at",p)
# X | z[p]
# with Control(eng, z):
# X | oracle_out
# print("num again",num)
# a1=sum(num)
# while a1>0:
# p = num.index(1)
# a1 = a1-1
# num[p]=0
# print("mark2 qubit at",p)
# X | z[p]
z = eng.allocate_qureg(qubitLength)
# start in uniform superposition
All(H) | z
# number of iterations we have to run:
num_it = int(math.pi / 4. * math.sqrt(1 << qubitLength))
#phi is the parameter of modified oracle
#varphi is the parameter of reflection across uniform superposition
theta = math.asin(math.sqrt(1 / (1 << qubitLength)))
phi = math.acos(-math.cos(2 * theta) /
(math.sin(2 * theta) * math.tan(
(2 * num_it + 1) * theta)))
varphi = math.atan(1 /
(math.sin(2 * theta) * math.sin(phi) * math.tan(
(2 * num_it + 1) * theta))) * 2
# prepare the oracle output qubit (the one that is flipped to indicate the
# solution. start in state 1/sqrt(2) * (|0> - |1>) s.t. a bit-flip turns
# into a (-1)-phase.
oracle_out = eng.allocate_qubit()
X | oracle_out
H | oracle_out
# run num_it iterations
with Loop(eng, num_it):
# oracle adds a (-1)-phase to the solution
with Compute(eng):
#be 0
for k in range(qubitLength):
if (num[k] == 0):
X | z[k]
# X | z[1]
# X | z[4]
# X | z[5]
with Control(eng, z):
X | oracle_out
Uncompute(eng)
# reflection across uniform superposition
with Compute(eng):
All(H) | z
All(X) | z
with Control(eng, z[0:-1]):
Z | z[-1]
Uncompute(eng)
# prepare the oracle output qubit (the one that is flipped to indicate the
# solution. start in state |1> s.t. a bit-flip turns into a e^(i*phi)-phase.
H | oracle_out
with Compute(eng):
#be 1
for k in range(qubitLength):
if (num[k] == 1):
X | z[k]
# X| z[0]
# X| z[2]
# X| z[3]
with Control(eng, z):
Rz(phi) | oracle_out
Ph(phi / 2) | oracle_out
Uncompute(eng)
with Compute(eng):
All(H) | z
All(X) | z
with Control(eng, z[0:-1]):
Rz(varphi) | z[-1]
Ph(varphi / 2) | z[-1]
Uncompute(eng)
All(Measure) | z
Measure | oracle_out
eng.flush()
xprime_i = ""
for z_i in z:
if (int(z_i) == 0):
xprime_i = xprime_i + '0'
else:
xprime_i = xprime_i + '1'
xprime = xprime_i
d_1 = xprime
print("d_1", d_1)
[d_1LSSED, memo] = LSSEDSTATE(simTraj, '1' + d_1 + '1', memo)
if (simType == "#" and
(d_1LSSED < d_0LSSED
and count_set_bitsString(d_1) == targetPoint - 2)) or (
simType == "SED" and
(d_1LSSED < d_0LSSED
and count_set_bitsString(d_1) < count_set_bitsString(d_0))):
print('d_1 < d_0')
i = 0
elif (simType == "#" and
(d_1LSSED == d_0LSSED
and count_set_bitsString(d_1) == targetPoint - 2)) or (
simType == "SED" and
(d_1LSSED < d_0LSSED and count_set_bitsString(d_1)
== count_set_bitsString(d_0))):
print('d_1 == d_0')
print("d_1", d_1)
# return '1'+d_0+'1'
shit = 1
return '1' + d_1 + '1'
print('set d_0=d_1')
d_0 = d_1
d_0LSSED = d_1LSSED
if (simType == "#"):
d_1 = 9999999
else:
d_1 = 9999999
print("break with c", c)
return '1' + d_0 + '1'
def grover_long(eng,
Dataset,
oracle,
threshold,
targetPoint=5,
LSSEDthreshold=0,
simType="#",
prevSED=0,
memo=[]):
"""
Runs modified Grover's algorithm to find an element in a set larger than a
given value threshold, using the provided quantum oracle.
Args:
eng (MainEngine): Main compiler engine to run Grover on.
Dataset(list): The set to search for an element.
oracle (function): Function accepting the engine, an n-qubit register,
Dataset, the threshold, and an output qubit which is flipped by the
oracle for the correct bit string.
threshold: the threshold.
Returns:
solution (list<int>): the location of Solution.
"""
N = pow(2, len(Dataset) - 2)
n = int(math.ceil(math.log(N, 2)))
# number of iterations we have to run:
num_it = int(math.sqrt(N) * 9 / 4)
m = 1
landa = 6 / 5
# run num_it iterations
i = 0
while i < num_it:
random.seed(i)
j = random.randint(0, int(m))
x = eng.allocate_qureg(n)
All(H) | x
oracle_out = eng.allocate_qubit()
X | oracle_out
H | oracle_out
with Loop(eng, j):
oracle(eng,
x,
Dataset,
threshold,
oracle_out,
targetPoint=targetPoint,
simType=simType,
LSSEDthreshold=LSSEDthreshold,
prevSED=prevSED,
memo=memo)
with Compute(eng):
All(H) | x
All(X) | x
with Control(eng, x[0:-1]):
Z | x[-1]
Uncompute(eng)
All(Measure) | x
Measure | oracle_out
k = 0
xvalue = 0
z_i = ""
for i in range(len(x)):
# print(int(x[k]))
# xvalue=xvalue+int(x[k])*(2**k)
if (int(x[i]) == 0):
z_i += '0'
else:
z_i += '1'
# k+=1
# print(z_i)
# print(int(x))
#
# print(int(x[i]))
# # if(int(x[i])==0):
# # z_i+='0'
# # else:
# # z_i+='1'
[curLSSED, memo] = LSSEDSTATE(simTraj, '1' + z_i + '1', memo)
if (simType == "#"):
if (count_set_bitsString(z_i) == (targetPoint - 2)):
if (curLSSED < threshold):
return [z_i, memo]
else:
if (((curLSSED < threshold and count_set_bitsString(z_i)
== count_set_bitsString(prevSED))
or count_set_bits(z_i) < count_set_bits(prevSED))
and curLSSED < LSSEDthreshold):
return [z_i, memo]
if (prevSED == 0 and curLSSED < LSSEDthreshold):
return [z_i, memo]
m = m * landa
i = i + 1
#fail to find a solution (with high probability the solution doesnot exist)
return ["no answer", memo]
