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 ]