def test_resource_counter():
resource_counter = ResourceCounter()
backend = DummyEngine(save_commands=True)
eng = MainEngine(backend, [resource_counter])
qubit1 = eng.allocate_qubit()
qubit2 = eng.allocate_qubit()
H | qubit1
X | qubit2
del qubit2
qubit3 = eng.allocate_qubit()
CNOT | (qubit1, qubit3)
Measure | (qubit1, qubit3)
assert int(qubit1) == int(qubit3)
assert int(qubit1) == 0
assert resource_counter.max_width == 2
str_repr = str(resource_counter)
assert str_repr.count("H") == 1
assert str_repr.count("X") == 2
assert str_repr.count("CX") == 1
assert str_repr.count("Allocate : 3") == 1
assert str_repr.count("Deallocate : 1") == 1
sent_gates = [cmd.gate for cmd in backend.received_commands]
assert sent_gates.count(H) == 1
assert sent_gates.count(X) == 2
assert sent_gates.count(Measure) == 1
def main():
x = 2
modulus = 2
for reg_size in range(2, 20):
reg_max_val = 1 << reg_size
while True:
modulus = random.randint(reg_max_val // 2 + 1, reg_max_val - 1)
x = random.randint(2, modulus - 1)
if modulus % 2 != 0 and fractions.gcd(x, modulus) == 1:
break
cnt = ResourceCounter()
eng = MainEngine(
backend=DummyEngine(),
engine_list=[
AutoReplacerEx(DecompositionRuleSet(modules=[decompositions])),
LimitedCapabilityEngine(allow_toffoli=True,
allow_single_qubit_gates=True,
allow_classes=[]),
cnt,
])
v1 = eng.allocate_qureg(reg_size)
v2 = eng.allocate_qureg(reg_size)
c = eng.allocate_qubit()
gate = ModularBimultiplicationGate(x, modulus)
gate & c | (v1, v2)
print()
print()
print("Register Size: {}".format(reg_size))
print("Gate count for controlled {}".format(gate))
print("\t{}".format(cnt).replace('\n', '\n\t'))
def run(x=4, N=7, param="run"):
"""
:param a: a<N and must be invertible mod[N]
:param N:
:param x:
:param param:
:return: |1> --> |(a**x) mod N>
"""
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(modules=[projectq.libs.math,
projectq.setups.decompositions])
compilerengines = [AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
resource_counter]
# create a main compiler engine
if param == "latex":
drawing_engine = CircuitDrawer()
eng = MainEngine(drawing_engine)
arcsinQ(eng, x, N)
return drawing_engine
if param == "count":
eng = MainEngine(resource_counter)
arcsinQ(eng, x, N)
return resource_counter
else:
eng = MainEngine(Simulator(), compilerengines)
return arcsinQ(eng, x, N)
def run():
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
InstructionFilter(high_level_gates),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# make the compiler and run the circuit on the simulator backend
#eng = MainEngine(Simulator(), compilerengines)
eng = MainEngine(resource_counter)
# print welcome message and ask the user for the number to factor
print(
"\n\t\033[37mprojectq\033[0m\n\t--------\n\tImplementation of Shor"
"\'s algorithm.",
end="")
N = int(input('\n\tNumber to factor: '))
print("\n\tFactoring N = {}: \033[0m".format(N), end="")
# choose a base at random:
a = N
while not gcd(a, N) == 1:
a = random.randint(2, N)
print("\na is " + str(a))
if not gcd(a, N) == 1:
print("\n\n\t\033[92mOoops, we were lucky: Chose non relative prime"
" by accident :)")
print("\tFactor: {}\033[0m".format(gcd(a, N)))
else:
# run the quantum subroutine
r = run_shor(eng, N, a, True)
print("\n\nr found : " + str(r))
# try to determine the factors
if r % 2 != 0:
r *= 2
apowrhalf = pow(a, r >> 1, N)
f1 = gcd(apowrhalf + 1, N)
f2 = gcd(apowrhalf - 1, N)
print("f1 = {}, f2 = {}".format(f1, f2))
if ((not f1 * f2 == N) and f1 * f2 > 1
and int(1. * N / (f1 * f2)) * f1 * f2 == N):
f1, f2 = f1 * f2, int(N / (f1 * f2))
if f1 * f2 == N and f1 > 1 and f2 > 1:
print(
"\n\n\t\033[92mFactors found :-) : {} * {} = {}\033[0m".format(
f1, f2, N))
else:
print("\n\n\t\033[91mBad luck: Found {} and {}\033[0m".format(
f1, f2))
return resource_counter # print resource usage
def run_adder(a=11, b=1, param="simulation"):
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# create a main compiler engine
if param == "latex":
drawing_engine = CircuitDrawer()
eng2 = MainEngine(drawing_engine)
[xa, xb] = initialisation(eng2, a, b)
adder(eng2, xa, xb)
measure(eng2, xa, xb)
print(drawing_engine.get_latex())
else:
eng = MainEngine(Simulator(), compilerengines)
[xa, xb] = initialisation(eng, a, b)
adder(eng, xa, xb)
print(measure(eng, xa, xb))
def test_resource_counter_depth_of_dag():
resource_counter = ResourceCounter()
eng = MainEngine(resource_counter, [])
assert resource_counter.depth_of_dag == 0
qb0 = eng.allocate_qubit()
qb1 = eng.allocate_qubit()
qb2 = eng.allocate_qubit()
QFT | qb0 + qb1 + qb2
assert resource_counter.depth_of_dag == 1
H | qb0
H | qb0
assert resource_counter.depth_of_dag == 3
CNOT | (qb0, qb1)
X | qb1
assert resource_counter.depth_of_dag == 5
Measure | qb1
Measure | qb1
assert resource_counter.depth_of_dag == 7
CNOT | (qb1, qb2)
Measure | qb2
assert resource_counter.depth_of_dag == 9
qb1[0].__del__()
qb2[0].__del__()
assert resource_counter.depth_of_dag == 9
qb0[0].__del__()
assert resource_counter.depth_of_dag == 9
def run_inv(a=11, b=1, param="simulation"):
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(modules=[projectq.libs.math,
projectq.setups.decompositions])
compilerengines = [AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
resource_counter]
# create a main compiler engine
a1 = a
b1 = b
if a == 0:
a1 = 1
if b == 0:
b1 = 1
n = max(int(math.log(a1, 2)), int(math.log(b1, 2))) + 1
if param == "latex":
drawing_engine = CircuitDrawer()
eng2 = MainEngine(drawing_engine)
xa = initialisation_n(eng2, a, n + 1)
xb = initialisation_n(eng2, b, n + 1)
# b --> phi(b)
QFT | xb
phi_adder(eng2, xa, xb)
with Dagger(eng2):
QFT | xb
All(Measure) | xa
All(Measure) | xb
eng2.flush()
print(drawing_engine.get_latex())
else:
eng = MainEngine(Simulator(), compilerengines)
xa = initialisation_n(eng, a, n + 1)
xb = initialisation_n(eng, b, n + 1)
# b --> phi(b)
QFT | xb
with Dagger(eng):
phi_adder(eng, xa, xb)
with Dagger(eng):
QFT | xb
All(Measure) | xa
All(Measure) | xb
eng.flush()
n = n+1
measurements_a = [0] * n
measurements_b = [0] * n
for k in range(n):
measurements_a[k] = int(xa[k])
measurements_b[k] = int(xb[k])
return [measurements_a, meas2int(measurements_b), measurements_b]
def test_resource_counter_isavailable():
resource_counter = ResourceCounter()
resource_counter.next_engine = MockEngine()
assert not resource_counter.is_available("test")
resource_counter.next_engine = None
resource_counter.is_last_engine = True
assert resource_counter.is_available("test")
def RSHIFT_resources(n):
#___________________initial__________________
resource_counter = ResourceCounter()
eng = MainEngine(resource_counter)
p = list_to_reg([0 for i in range(floor(log2(n)))],eng)
x = list_to_reg([0 for i in range(n)],eng)
print('Getting resources for ' + str(len(x)) + ' right shift circuit.')
RSHIFT(p,x)
eng.flush()
print(resource_counter)
def Fn_resources(n):
#___________________initial__________________
resource_counter = ResourceCounter()
eng = MainEngine(resource_counter)
f = list_to_reg([0],eng)
p = list_to_reg([0 for i in range(ceil(log2(n)))],eng)
x = list_to_reg([0 for i in range(n)],eng)
print('Getting resources for ' + str(len(x)) + 'bit first ones circuit.')
Fn(f,p,x)
eng.flush()
print(resource_counter)
def _2sresources(number_of_bits = 16):
print('getting costs of ' + str(number_of_bits) + ' bit 2s complement...')
#___________________initial__________________
resource_counter = ResourceCounter()
eng = MainEngine(resource_counter)
a = [0 for i in range(number_of_bits)]
a = list_to_reg( a, eng) #one extra bit (in most significant) needed for addition
z = list_to_reg([0 for _ in a]+[0],eng)
_2scomplement(a,z)
All(Measure) | a+z
eng.flush()
print(resource_counter)
def CRightShift_resources(k):
#___________________initial__________________
resource_counter = ResourceCounter()
eng = MainEngine(resource_counter)
control = list_to_reg([0],eng)
m = k #case when mantissa is 13 bits
x = list_to_reg([0 for i in range(m)],eng)
x = x[::-1]#for right swap
print('Getting resources for ' + str(len(x)) + ' controlled shift by 1 circuit.')
for i in range(0,m-1): C(Swap,1)|(control,x[i],x[i+1] )
Measure | control
Measure | x #for tex purposes
eng.flush()
print(resource_counter)
def MUL_resources(number_of_bits = 16):
print('getting costs of ' + str(number_of_bits) + ' unsigned multiplication...')
#___________________initial__________________
resource_counter = ResourceCounter()
eng = MainEngine(resource_counter)
a = [0 for i in range(number_of_bits)]
b = [0 for i in range(number_of_bits)]
n = len(a)
z = list_to_reg([0 for _ in range(2*n)],eng)
a = list_to_reg( a, eng) #one extra bit (in most significant) needed for addition
b = list_to_reg(b, eng)
fixed_MUL(a,b,z, eng = eng)
eng.flush()
print(resource_counter)
def ADD_resources(number_of_bits = 16):
print('getting costs of ' + str(number_of_bits) + ' bit addition...')
#___________________initial__________________
resource_counter = ResourceCounter()
eng = MainEngine(resource_counter)
a = [0 for i in range(number_of_bits)]
b = [0 for i in range(number_of_bits)]
a = list_to_reg( a, eng) #one extra bit (in most significant) needed for addition
z = list_to_reg([0],eng)
b = list_to_reg(b, eng)
#___________________circuit___________________
ADD(a,b,z)
#___________________measure___________________
eng.flush()
print(resource_counter)
def test_resource_counter_measurement():
eng = MainEngine(ResourceCounter(), [])
qb1 = WeakQubitRef(engine=eng, idx=1)
qb2 = WeakQubitRef(engine=eng, idx=2)
cmd0 = Command(engine=eng, gate=Allocate, qubits=([qb1],))
cmd1 = Command(engine=eng, gate=Measure, qubits=([qb1],), controls=[],
tags=[LogicalQubitIDTag(2)])
with pytest.raises(NotYetMeasuredError):
int(qb1)
with pytest.raises(NotYetMeasuredError):
int(qb2)
eng.send([cmd0, cmd1])
eng.flush()
with pytest.raises(NotYetMeasuredError):
int(qb1)
assert int(qb2) == 0
def get_engine(api=None):
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
InstructionFilter(high_level_gates),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# make the compiler and run the circuit on the simulator backend
backend = Simulator()
return MainEngine(backend, compilerengines), backend
def test_resource_counter():
resource_counter = ResourceCounter()
backend = DummyEngine(save_commands=True)
eng = MainEngine(backend, [resource_counter])
qubit1 = eng.allocate_qubit()
qubit2 = eng.allocate_qubit()
H | qubit1
X | qubit2
del qubit2
qubit3 = eng.allocate_qubit()
CNOT | (qubit1, qubit3)
Rz(0.1) | qubit1
Rz(0.3) | qubit1
Rzz(0.5) | qubit1
All(Measure) | qubit1 + qubit3
with pytest.raises(NotYetMeasuredError):
int(qubit1)
assert resource_counter.max_width == 2
assert resource_counter.depth_of_dag == 6
str_repr = str(resource_counter)
assert str_repr.count(" HGate : 1") == 1
assert str_repr.count(" XGate : 1") == 1
assert str_repr.count(" CXGate : 1") == 1
assert str_repr.count(" Rz : 2") == 1
assert str_repr.count(" AllocateQubitGate : 3") == 1
assert str_repr.count(" DeallocateQubitGate : 1") == 1
assert str_repr.count(" H : 1") == 1
assert str_repr.count(" X : 1") == 1
assert str_repr.count(" CX : 1") == 1
assert str_repr.count(" Rz(0.1) : 1") == 1
assert str_repr.count(" Rz(0.3) : 1") == 1
assert str_repr.count(" Allocate : 3") == 1
assert str_repr.count(" Deallocate : 1") == 1
sent_gates = [cmd.gate for cmd in backend.received_commands]
assert sent_gates.count(H) == 1
assert sent_gates.count(X) == 2
assert sent_gates.count(Measure) == 2
def run(args, param="simulation"):
"""
Be careful the Measure command can take a lot of time to execute as you can create as much as qubit as you want
:param args: list of int
:param param: choose between simulation or latex
:return:
"""
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# create a main compiler engine
if param == "latex":
drawing_engine = CircuitDrawer()
eng2 = MainEngine(drawing_engine)
Xreg = initialisation(eng2, args)
m = len(Xreg)
All(Measure) | Xreg
eng2.flush()
print(drawing_engine.get_latex())
else:
eng = MainEngine(Simulator(), compilerengines)
Xreg = initialisation(eng, args)
m = len(Xreg)
n = Xreg[0].__len__()
for i in range(m):
All(Measure) | Xreg[i]
eng.flush()
measurement = []
for i in range(m):
measurement.append([0] * n)
for k in range(n):
measurement[i][k] = int(Xreg[i][k])
return measurement
g = cmd.gate
if g == QFT or get_inverse(g) == QFT or g == Swap:
return True
if isinstance(g, BasicMathGate):
return False
if isinstance(g, AddConstant):
return True
elif isinstance(g, AddConstantModN):
return True
return False
return eng.next_engine.is_available(cmd)
if __name__ == "__main__":
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
InstructionFilter(high_level_gates),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# GET Input number from Command line
parser = argparse.ArgumentParser(description='Shor')
parser.add_argument("--number",
print('Enter password')
password = getpass()
else:
email, password = QI_EMAIL, QI_PASSWORD
return get_basic_authentication(email, password)
if __name__ == '__main__':
# Remote Quantum-Inspire backend #
authentication = get_authentication()
qi = QuantumInspireAPI(r'https://api.quantum-inspire.com/', authentication)
compiler_engines = restrictedgateset.get_engine_list(
one_qubit_gates="any", two_qubit_gates=(CNOT, CZ, Toffoli))
compiler_engines.extend([ResourceCounter()])
qi_backend = QIBackend(quantum_inspire_api=qi)
qi_engine = MainEngine(backend=qi_backend, engine_list=compiler_engines)
# Run remote Grover search to find a n-bit solution
result_qi = run_grover(qi_engine, 3, alternating_bits_oracle)
print("\nResult from the remote Quantum-Inspire backend: {}".format(
result_qi))
# Local ProjectQ simulator backend #
compiler_engines = restrictedgateset.get_engine_list(one_qubit_gates="any",
two_qubit_gates=(CNOT,
CZ))
compiler_engines.append(ResourceCounter())
local_engine = MainEngine(Simulator(), compiler_engines)
def run(a=4, b=6, N=7, x=2, param="count"):
"""
Last update 19/02 : nb of gate linear in log(N)
Be careful this algo is a bit long to execute
|b> --> |b+(ax) mod N> works for
:param a:
:param b:
:param N:
:param x:
:param param:
:return:
"""
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# create a main compiler engine
n = int(math.log(N, 2)) + 1
if param == "latex":
drawing_engine = CircuitDrawer()
eng2 = MainEngine(drawing_engine)
xN = initialisation_n(eng2, N, n + 1)
xx = initialisation_n(eng2, x, n + 1)
xb = initialisation_n(eng2, b, n + 1)
[xc, aux] = initialisation(eng2, [1, 0])
cMultModN_non_Dagger(eng2, a, xb, xx, xN, aux, xc)
eng2.flush()
Measure | aux
Measure | xc
All(Measure) | xx
All(Measure) | xb
All(Measure) | xN
eng2.flush()
print(drawing_engine.get_latex())
else:
if param == "count":
eng = MainEngine(resource_counter)
else:
eng = MainEngine(Simulator(), compilerengines)
xN = initialisation_n(eng, N, n + 1)
xx = initialisation_n(eng, x, n + 1)
xb = initialisation_n(eng, b, n + 1)
[aux, xc] = initialisation(eng, [0, 1])
cMultModN_non_Dagger(eng, a, xb, xx, xN, aux, xc, N)
Measure | aux
Measure | xc
All(Measure) | xx
All(Measure) | xb
All(Measure) | xN
eng.flush()
if param == "count":
return resource_counter
measurements_b = [0] * n
measurements_x = [0] * n
measurements_N = [0] * n
for k in range(n):
measurements_b[k] = int(xb[k])
measurements_N[k] = int(xN[k])
measurements_x[k] = int(xx[k])
mes_aux = int(aux[0])
mes_c = int(aux[0])
return [
measurements_b,
meas2int(measurements_b), (b + a * x) % N, measurements_N,
measurements_x, mes_aux, mes_c,
meas2int(measurements_b),
meas2int(measurements_N),
meas2int(measurements_x)
]
def get_engine(api=None):
compiler_engines = restrictedgateset.get_engine_list(one_qubit_gates="any", two_qubit_gates=(CNOT, CZ, Toffoli))
compiler_engines.extend([ResourceCounter()])
qi_backend = QIBackend(quantum_inspire_api=api)
return MainEngine(backend=qi_backend, engine_list=compiler_engines), qi_backend
def run(a=4, N=7, x=2, param="count"):
"""
|b> --> |b+(ax) mod N>
nb of gate ~454*log2(N)
:param a: a<N and must be invertible mod[N]
:param N:
:param x:
:param param:
:return:
"""
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# create a main compiler engine
a = a % N
inv_a = mod_inv(a, N)
b = 0
n = int(math.log(N, 2)) + 1
if param == "latex":
drawing_engine = CircuitDrawer()
eng2 = MainEngine(drawing_engine)
xN = initialisation_n(eng2, N, n + 1)
xx = initialisation_n(eng2, x, n + 1)
xb = initialisation_n(eng2, b, n + 1)
[xc, aux] = initialisation(eng2, [1, 0])
gateUa(eng2, a, inv_a, xx, xb, xN, aux, xc, N)
eng2.flush()
Measure | aux
Measure | xc
All(Measure) | xx
All(Measure) | xb
All(Measure) | xN
eng2.flush()
print(drawing_engine.get_latex())
else:
if param == "count":
eng = MainEngine(resource_counter)
else:
eng = MainEngine(Simulator(), compilerengines)
xN = initialisation_n(eng, N, n + 1)
xx = initialisation_n(eng, x, n + 1)
xb = initialisation_n(eng, b, n + 1)
[xc, aux] = initialisation(eng, [1, 0])
gateUa(eng, a, inv_a, xx, xb, xN, aux, xc, N)
Measure | aux
Measure | xc
All(Measure) | xx
All(Measure) | xb
All(Measure) | xN
eng.flush()
if param == "count":
return resource_counter
measurements_b = [0] * n
measurements_x = [0] * n
measurements_N = [0] * n
for k in range(n):
measurements_b[k] = int(xb[k])
measurements_N[k] = int(xN[k])
measurements_x[k] = int(xx[k])
mes_aux = int(aux[0])
mes_c = int(aux[0])
assert int(xb[n]) == 0
assert int(xN[n]) == 0
assert int(xx[n]) == 0
assert meas2int(measurements_b) == 0
assert meas2int(measurements_N) == N
assert mes_aux == 0
return [(a * x) % N, meas2int(measurements_x), measurements_x, mes_c]
def run(a=4, N=7, x=2, param="run"):
"""
:param a: a<N and must be invertible mod[N]
:param N:
:param x:
:param param:
:return: |1> --> |(a**x) mod N>
"""
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# create a main compiler engine
a = a % N
b = 0
n = int(math.log(N, 2)) + 1
if param == "latex":
drawing_engine = CircuitDrawer()
eng = MainEngine(drawing_engine)
if param == "count":
eng = MainEngine(resource_counter)
else:
eng = MainEngine(Simulator(), compilerengines)
output = initialisation_n(eng, 1, n + 1)
xN = initialisation_n(eng, N, n + 1)
xx = initialisation_n(eng, x, n + 1)
xb = initialisation_n(eng, b, n + 1)
aux = initialisation_n(eng, 0, 1)
expoModN(eng, a, output, xb, xN, aux, xx, N)
Measure | aux
All(Measure) | output
All(Measure) | xx
All(Measure) | xb
All(Measure) | xN
eng.flush()
if param == "count":
return resource_counter
if param == "latex":
print(drawing_engine.get_latex())
measurements_b = [0] * n
measurements_x = [0] * n
measurements_N = [0] * n
for k in range(n):
measurements_b[k] = int(xb[k])
measurements_N[k] = int(xN[k])
measurements_x[k] = int(output[k])
mes_aux = int(aux[0])
assert int(xb[n]) == 0
assert int(xN[n]) == 0
assert int(xx[n]) == 0
assert meas2int(measurements_b) == 0
assert meas2int(measurements_N) == N
assert mes_aux == 0
return [(a**x) % N, meas2int(measurements_x), measurements_x]
def test_resource_counter_str_when_empty():
assert isinstance(str(ResourceCounter()), str)
def run(a=11, b=1, N=12, param="simulation"):
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# create a main compiler engine
n = int(math.log(N, 2)) + 1
if param == "latex":
drawing_engine = CircuitDrawer()
eng2 = MainEngine(drawing_engine)
xN = initialisation_n(eng2, N, n + 1)
xa = initialisation_n(eng2, a, n + 1)
xb = initialisation_n(eng2, b, n + 1)
c1 = initialisation_n(eng2, 1)
c2 = initialisation_n(eng2, 1)
aux = initialisation_n(eng2, 0)
# b --> phi(b)
QFT | xb
modularAdder(eng2, xa, xb, xN, c1, c2, aux)
with Dagger(eng2):
QFT | xb
Measure | c1
Measure | c2
Measure | aux
All(Measure) | xa
All(Measure) | xb
All(Measure) | xN
eng2.flush()
print(drawing_engine.get_latex())
else:
eng = MainEngine(Simulator(), compilerengines)
xN = initialisation_n(eng, N, n + 1)
xa = initialisation_n(eng, a, n + 1)
xb = initialisation_n(eng, b, n + 1)
[c1, c2, aux] = initialisation(eng, [1, 1, 0])
# b --> phi(b)
QFT | xb
modularAdder(eng, xa, xb, xN, c1, c2, aux)
with Dagger(eng):
QFT | xb
Measure | c1
Measure | c2
Measure | aux
All(Measure) | xa
All(Measure) | xb
All(Measure) | xN
eng.flush()
measurements_a = [0] * n
measurements_b = [0] * n
measurements_N = [0] * n
for k in range(n):
measurements_a[k] = int(xa[k])
measurements_b[k] = int(xb[k])
measurements_N[k] = int(xN[k])
return [
measurements_a, measurements_b,
int(xb[n]), measurements_N,
int(aux[0]),
int(c1[0]),
int(c2[0]),
meas2int(measurements_b), (a + b) % N
]
