From 2120e6fbf59d658d6ca42b48f15742b348b5d0e5 Mon Sep 17 00:00:00 2001 From: kogeletey Date: Mon, 24 Jul 2023 14:26:29 +0300 Subject: [PATCH] init: repository publish --- .gitignore | 3 + bench-cirq/deutsch_algorithm.py | 43 ++++ bench-cirq/grover_algorithm.py | 61 +++++ bench-cirq/shor_algorithm.py | 143 ++++++++++++ bench-qiskit/deutsch_alogrithm.py | 85 +++++++ bench-qiskit/grover_algorithm.py | 49 ++++ bench-qiskit/shor_algorithm.py | 376 ++++++++++++++++++++++++++++++ license | 14 ++ quantum_runner/__init__.py | 31 +++ 9 files changed, 805 insertions(+) create mode 100644 .gitignore create mode 100644 bench-cirq/deutsch_algorithm.py create mode 100644 bench-cirq/grover_algorithm.py create mode 100644 bench-cirq/shor_algorithm.py create mode 100644 bench-qiskit/deutsch_alogrithm.py create mode 100644 bench-qiskit/grover_algorithm.py create mode 100644 bench-qiskit/shor_algorithm.py create mode 100644 license create mode 100644 quantum_runner/__init__.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..77ed492 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +libs/ +.env +__pycache__/ diff --git a/bench-cirq/deutsch_algorithm.py b/bench-cirq/deutsch_algorithm.py new file mode 100644 index 0000000..632b80b --- /dev/null +++ b/bench-cirq/deutsch_algorithm.py @@ -0,0 +1,43 @@ +from cirq import LineQubit,Circuit,CNOT,X,H,measure +from cirq import Simulator + +from qiskit import IBMQ + +from quantum_runner import quantum_simulate,setup_IBM,cirq_qasm + +from random import randint + +q0,q1 = LineQubit.range(2) + +ffunction = [randint(0, 1) for _ in range(2)] + +# создаем вентиль для генерации функции +def make_oracle(q0,q1,ffunction): + if ffunction[0]: + # используем контролируемый вентиль отрицания и матрицу Паули по координате x, sigma_x + yield [CNOT(q0,q1), X(q1)] + if ffunction[1]: + yield CNOT(q0,q1) + +print(f"f(x) = <{', '.join(str(e) for e in ffunction)}>") + +circuit = Circuit() + +# создаем кубиты используя вентиль Адамара и матрицу Паули + +circuit.append([X(q1),H(q1),H(q0)]) + +# добавляем функцию +circuit.append(make_oracle(q0,q1,ffunction)) + +# проведем измерение +circuit.append([H(q0),measure(q0)]) + +print(circuit) +print(Simulator().run(circuit)) + +# запуск на квантовом компьютере + +setup_IBM() +provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main') +print(quantum_simulate(cirq_qasm(circuit,(q0,q1,)),provider.get_backend('ibm_lagos'),True)) diff --git a/bench-cirq/grover_algorithm.py b/bench-cirq/grover_algorithm.py new file mode 100644 index 0000000..313cf05 --- /dev/null +++ b/bench-cirq/grover_algorithm.py @@ -0,0 +1,61 @@ +# https://github.com/quantumlib/Cirq/blob/master/examples/grover.py +# https://quantum-ods.github.io/qmlcourse/book/qcalgo/ru/grovers_algorithm.html + +from ctypes import wstring_at +from random import randint +from cirq import Circuit,X,H,CNOT,TOFFOLI,GridQubit,measure +from cirq import Simulator + +from qiskit import IBMQ + +from quantum_runner import quantum_simulate,setup_IBM,cirq_qasm + +def oracle(iqs,oq,bits): + yield (X(q) for (q, bit) in zip(iqs,bits) if not bit) + yield (TOFFOLI(iqs[0],iqs[1],oq)) + yield (X(q) for (q,bit) in zip(iqs,bits) if not bit) + +circuit = Circuit() + +qb_count = 2 + +iqs = [GridQubit(i,0) for i in range(qb_count)] +oq = GridQubit(qb_count,0) +bits = [randint(0, 1) for _ in range(qb_count)] + +circuit.append([X(oq),H(oq),H.on_each(iqs)]) + +circuit.append(oracle(iqs,oq,bits)) + +# Строим оператор Гровера +circuit.append(H.on_each(iqs)) +circuit.append(X.on_each(iqs)) +circuit.append(H.on(iqs[1])) +circuit.append(CNOT.on(iqs[0],iqs[1])) +circuit.append(H.on(iqs[1])) +circuit.append(X.on_each(iqs)) +circuit.append(H.on_each(iqs)) + +circuit.append(measure(iqs, key="result")) + +print(circuit) + +result = Simulator().run(circuit,repetitions=10) + +def bitstring(bits): + return ''.join(str(int(b)) for b in bits) + +frequencies = result.histogram(key='result',fold_func=bitstring) + +print(f"результат",frequencies) +print(f"наиболее распространеная битовая строка",frequencies.most_common(1)[0][0]) + +setup_IBM() + +provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main') + +quantum_simulate( + cirq_qasm(circuit), + provider.get_backend('ibmq_lima'), + True +) diff --git a/bench-cirq/shor_algorithm.py b/bench-cirq/shor_algorithm.py new file mode 100644 index 0000000..9d536bb --- /dev/null +++ b/bench-cirq/shor_algorithm.py @@ -0,0 +1,143 @@ +# https://github.com/dmitrifried/Shors-Algorithm-in-Cirq/blob/master/Shor's%20Algorithm%20in%20Cirq.ipynb + +from math import gcd,floor,ceil,pow,log2 +from random import randint +from typing import Optional,Sequence,Union,Callable +from fractions import Fraction + +from sympy import isprime + +from cirq import ArithmeticGate,Circuit,X,H,qft,measure,LineQubit +from cirq import CircuitDiagramInfoArgs,CircuitDiagramInfo,Result +from cirq import Simulator + +def classic_order_finder(x: int, n: int) -> Optional[int]: + """ + Поиск делителя классическим способом + """ + if x < 2 or n <= x or gcd(x, n) > 1: + raise ValueError(f'Invalid x={x} for modulus n={n}.') + r, y = 1, x + while y != 1: + y = (x * y) % n + r += 1 + return r + +class ModularExp(ArithmeticGate): + def __init__(self, target: Sequence[int], exponent: Union[int, Sequence[int]], base: int, modulus: int) -> None: + if len(target) < modulus.bit_length(): + raise ValueError( + f'Регистр с {len(target)} кубитами маленький для {modulus}' + ) + self.target = target + self.exponent = exponent + self.base = base + self.modulus = modulus + + def registers(self) -> Sequence[Union[int, Sequence[int]]]: + return self.target, self.exponent, self.base, self.modulus + + def with_registers(self, *new_registers: Union[int, Sequence[int]]) -> 'ModularExp': + if len(new_registers) != 4: + raise ValueError( + f'Expected 4 registers (target, exponent, base, ' + f'modulus), but got {len(new_registers)}' + ) + target, exponent, base, modulus = new_registers + if not isinstance(target, Sequence): + raise ValueError(f'Метка должна быть регистром кубитов {type(target)}') + if not isinstance(modulus,int): + raise ValueError(f'модуль это классическая константа {type(modulus)}') + if not isinstance(base,int): + raise ValueError(f'база у числа это классическая константа {type(base)}') + return ModularExp(target, exponent, base, modulus) + def apply(self, *register_values: int) -> int: + assert len(register_values) == 4 + target, exponent, base, modulus = register_values + if target >= modulus: + return target + return (target * base**exponent) % modulus + def _circuit_diagram_info_(self, args: CircuitDiagramInfoArgs) -> CircuitDiagramInfo: + assert args.known_qubits is not None + wire_symbols = [f't{i}' for i in range(len(self.target))] + e_str = str(self.exponent) + if isinstance(self.exponent, Sequence): + e_str = 'e' + wire_symbols += [f'e{i}' for i in range(len(self.exponent))] + wire_symbols[0] = f'ModularExp(t*{self.base}**{e_str} % {self.modulus})' + return CircuitDiagramInfo(wire_symbols=tuple(wire_symbols)) + +def make_order_finding_circuit(x: int, n: int) -> Circuit: + L = n.bit_length() + target = LineQubit.range(L) + exponent = LineQubit.range(L, 3 * L + 3) + return Circuit( + X(target[L - 1]), + H.on_each(*exponent), + ModularExp([2] * len(target), [2] * len(exponent), x, n).on(*target + exponent), + qft(*exponent, inverse=True), + measure(*exponent, key='exponent'), + ) + +def read_eigenphase(result: Result) -> float: + exponent_as_integer = result.data['exponent'][0] + exponent_num_bits = result.measurements['exponent'].shape[1] + return float(exponent_as_integer / 2**exponent_num_bits) + +def quantum_order_finder(x: int, n: int) -> Optional[int]: + if x < 2 or n <= x or gcd(x, n) > 1: + raise ValueError(f'Неправильный x={x} для модуля n={n}.') + + circuit = make_order_finding_circuit(x, n) + result = Simulator().run(circuit) + eigenphase = read_eigenphase(result) + f = Fraction.from_float(eigenphase).limit_denominator(n) + if f.numerator == 0: + return None + r = f.denominator + if x**r % n != 1: + return None + print(circuit) + return r + +def find_factor_of_prime_power(n: int) -> Optional[int]: + for k in range(2, floor(log2(n)) + 1): + c = pow(n, 1 / k) + c1 =floor(c) + if c1**k == n: + return c1 + c2 = ceil(c) + if c2**k == n: + return c2 + return None + +def find_factor( + n: int, order_finder: Callable[[int, int], Optional[int]], max_attempts: int = 30 +) -> Optional[int]: + if isprime(n): + return None + if n % 2 == 0: + return 2 + c = find_factor_of_prime_power(n) + if c is not None: + return c + for _ in range(max_attempts): + x = randint(2, n - 1) + c = gcd(x, n) + if 1 < c < n: + return c + r = order_finder(x, n) + if r is None: + continue + if r % 2 != 0: + continue + y = x ** (r // 2) % n + assert 1 < y < n + c = gcd(y - 1, n) + if 1 < c < n: + return c + return None + +n = 33 +d = find_factor(n, quantum_order_finder) + diff --git a/bench-qiskit/deutsch_alogrithm.py b/bench-qiskit/deutsch_alogrithm.py new file mode 100644 index 0000000..f2eeef0 --- /dev/null +++ b/bench-qiskit/deutsch_alogrithm.py @@ -0,0 +1,85 @@ +# https://github.com/qiskit-community/qiskit-community-tutorials/blob/master/algorithms/deutsch_jozsa.ipynb +# https://github.com/mrtkp9993/QuantumComputingExamples +# https://github.com/DavitKhach/quantum-algorithms-tutorials/blob/master/quantum_parallelism_Deutsch_Jozsa.ipynb +# https://fullstackquantumcomputation.tech/blog/deutsch-algorithm/ +# https://www.mlq.ai/quantum-programming-with-qiskit/ +# https://github.com/przecze/deutschs_algorithm_in_qiskit_vs_cirq/blob/main/common.py +from random import randint + +from qiskit import QuantumCircuit,QuantumRegister,ClassicalRegister +from qiskit import BasicAer,IBMQ +from qiskit.tools.monitor import job_monitor + +from qiskit import transpile + +from quantum_runner import quantum_simulate,setup_IBM + + +# количество создаваемых битов +n = 1 + +# создаем функции +ff = randint(0, n) + +if ff !=0: + randint(1,2**n) + +# создание n-кубитов в системе + +qr = QuantumRegister(n+1) + +# создание n классических битов, для записи измерений + +cr = ClassicalRegister(n) + +circuit = QuantumCircuit(qr,cr) + +# создаем вспомогательные кубиты + +circuit.x(qr[n]) + +circuit.h(qr[n]) + +# Барьер нужен для группировки отдельных частей цепи +circuit.barrier() + +# Первая часть, это подготовка суперпозиции состояний. +# Для этого используем вентиль Адамара + +circuit.h(qr[0]) +circuit.h(qr[1]) + +circuit.barrier() + +# Создаем квантовый оракул, используя контроллер +circuit.cx(qr[0],qr[1]) + +circuit.barrier() + +# Применяем вентиль уже к оракулу + +for i in range(n): + circuit.h(qr[i]) + +circuit.barrier() + +# Измеряем кубит + +for i in range(n): + circuit.measure(qr[i],cr[i]) + +# Запустим локально + +backend = BasicAer.get_backend("qasm_simulator") +results = quantum_simulate(circuit,backend,True) +results = list(results.keys()) + +print(circuit) +print(f"q({ff})=",results) + +#setup_IBM() +#provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main') +#backend = provider.get_backend('ibmq_lima') +#job_monitor(quantum_simulate(circuit,backend), interval=2) + +#print(quantum_simulate(circuit,backend,True)) diff --git a/bench-qiskit/grover_algorithm.py b/bench-qiskit/grover_algorithm.py new file mode 100644 index 0000000..8a955e8 --- /dev/null +++ b/bench-qiskit/grover_algorithm.py @@ -0,0 +1,49 @@ +# https://www.qmunity.tech/tutorials/grovers-algorithm-using-2-qubits +from qiskit import QuantumCircuit +from qiskit import BasicAer,IBMQ + +from quantum_runner import setup_IBM,quantum_simulate + +qb_count = 2 + +circuit = QuantumCircuit(qb_count) + +circuit.h(0) +circuit.h(1) + +circuit.barrier() + +# создаем оракул для котроллируемого вентиля по z +circuit.cz(0,1) +circuit.barrier() + +# создаем оператор гровера +for k in range(0,qb_count): + circuit.h(k) +for k in range(0,qb_count): + circuit.x(k) + +circuit.h(1) +circuit.cx(0,1) + +circuit.x(0) +circuit.h(1) +circuit.h(0) +circuit.x(1) +circuit.h(1) + +circuit.barrier() + +circuit.measure_all() + +print(circuit) + +backend = BasicAer.get_backend("qasm_simulator") +results = quantum_simulate(circuit,backend,True) + +print(quantum_simulate(circuit,backend,True)) + + +setup_IBM() +provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main') +quantum_simulate(circuit,provider.get_backend('ibm_lagos'),True) diff --git a/bench-qiskit/shor_algorithm.py b/bench-qiskit/shor_algorithm.py new file mode 100644 index 0000000..9c618be --- /dev/null +++ b/bench-qiskit/shor_algorithm.py @@ -0,0 +1,376 @@ +# https://qiskit.org/documentation/tutorials/circuits/3_summary_of_quantum_operations.html +# https://github.com/olekssy/qiskit-shors/blob/master/shors.py +# https://quantumcomputinguk.org/tutorials/shors-algorithm-with-code + +from math import pow,gcd,floor,isinf,ceil,log + +from numpy import zeros,pi + +from fractions import Fraction +from array import array + +from qiskit import QuantumRegister,ClassicalRegister,QuantumCircuit +from qiskit import IBMQ + +from quantum_runner import setup_IBM,quantum_simulate + +def check_if_power(N): + b=2 + while (2**b) <= N: + a = 1 + c = N + while (c-a) >= 2: + m = int( (a+c)/2 ) + + if (m**b) < (N+1): + p = int( (m**b) ) + else: + p = int(N+1) + + if int(p) == int(N): + print('N is {0}^{1}'.format(int(m),int(b)) ) + return True + + if p=0: + circuit.h(up_reg[i]) + j=i-1 + while j>=0: + if (pi)/(pow(2,(i-j))) > 0: + circuit.crz( (pi)/(pow(2,(i-j))) , up_reg[i] , up_reg[j] ) + j=j-1 + i=i-1 + + if with_swaps==1: + i=0 + while i < ((n-1)/2): + circuit.swap(up_reg[i], up_reg[n-1-i]) + i=i+1 + +def create_inverse_QFT(circuit,up_reg,n,with_swaps): + if with_swaps==1: + i=0 + while i < ((n-1)/2): + circuit.swap(up_reg[i], up_reg[n-1-i]) + i=i+1 + + i=0 + while i=0: + if (pi)/(pow(2,(j-y))) > 0: + circuit.crz( - (pi)/(pow(2,(j-y))) , up_reg[j] , up_reg[y] ) + + +def egcd(a, b): + if a == 0: + return (b, 0, 1) + else: + g, y, x = egcd(b % a, a) + return (g, x - (b // a) * y, y) + +def modinv(a, m): + g, x, y = egcd(a, m) + if g != 1: + raise Exception('modular inverse does not exist') + else: + return x % m + +def get_factors(x_value,t_upper,N,a): + + if x_value<=0: + print('x_value is <= 0, there are no continued fractions\n') + return False + +# print('Running continued fractions for this case\n') + + T = pow(2,t_upper) + + x_over_T = x_value/T + + i=0 + b = array('i') + t = array('f') + + b.append(floor(x_over_T)) + t.append(x_over_T - b[i]) + + while i>=0: + + if i>0: + b.append( floor( 1 / (t[i-1]) ) ) + t.append( ( 1 / (t[i-1]) ) - b[i] ) + + + aux = 0 + j=i + while j>0: + aux = 1 / ( b[j] + aux ) + j = j-1 + + aux = aux + b[0] + + frac = Fraction(aux).limit_denominator() + den=frac.denominator + + print('Approximation number {0} of continued fractions:'.format(i+1)) + print("Numerator:{0} \t\t Denominator: {1}\n".format(frac.numerator,frac.denominator)) + + """ Increment i for next iteration """ + i=i+1 + + if (den%2) == 1: + if i>=15: + print('Returning because have already done too much tries') + return False + print('Odd denominator, will try next iteration of continued fractions\n') + continue + + """ If denominator even, try to get factors of N """ + + """ Get the exponential a^(r/2) """ + + exponential = 0 + + if den<1000: + exponential=pow(a , (den/2)) + + """ Check if the value is too big or not """ + if isinf(exponential)==1 or exponential>1000000000: + print('Denominator of continued fraction is too big!\n') + aux_out = input('Input number 1 if you want to continue searching, other if you do not: ') + if aux_out != '1': + return False + else: + continue + + putting_plus = int(exponential + 1) + + putting_minus = int(exponential - 1) + + one_factor = gcd(putting_plus,N) + other_factor = gcd(putting_minus,N) + + """ Check if the factors found are trivial factors or are the desired + factors """ + + if one_factor==1 or one_factor==N or other_factor==1 or other_factor==N: + print('Found just trivial factors, not good enough\n') + if t[i-1]==0: + print('The continued fractions found exactly x_final/(2^(2n)) , leaving funtion\n') + return False + else: + """ Return if already too much tries and numbers are huge """ + print('Returning because have already done too many tries\n') + return False + else: + print('The factors of {0} are {1} and {2}\n'.format(N,one_factor,other_factor)) + print('Found the desired factors!\n') + return True + +def getAngles(a,N): + s=bin(int(a))[2:].zfill(N) + angles=zeros([N]) + for i in range(0, N): + for j in range(i,N): + if s[j]=='1': + angles[N-i-1]+=pow(2, -(j-i)) + angles[N-i-1]*=pi + return angles + +def ccphase(circuit,angle,ctl1,ctl2,tgt): + circuit.crz(angle/2,ctl1,tgt) + circuit.cx(ctl2,ctl1) + circuit.crz(-angle/2,ctl1,tgt) + circuit.cx(ctl2,ctl1) + circuit.crz(angle/2,ctl2,tgt) + +def phiADD(circuit,q,a,N,inv): + angle=getAngles(a,N) + for i in range(0,N): + if inv==0: + circuit.p(angle[i],q[i]) + else: + circuit.p(-angle[i],q[i]) + +def cphiADD(circuit,q,ctl,a,n,inv): + angle=getAngles(a,n) + for i in range(0,n): + if inv==0: + circuit.crz(angle[i],ctl,q[i]) + else: + circuit.crz(-angle[i],ctl,q[i]) + +def ccphiADD(circuit,q,ctl1,ctl2,a,n,inv): + angle=getAngles(a,n) + for i in range(0,n): + if inv==0: + ccphase(circuit,angle[i],ctl1,ctl2,q[i]) + else: + ccphase(circuit,-angle[i],ctl1,ctl2,q[i]) + +def ccphiADDmodN(circuit, q, ctl1, ctl2, aux, a, N, n): + ccphiADD(circuit, q, ctl1, ctl2, a, n, 0) + phiADD(circuit, q, N, n, 1) + create_inverse_QFT(circuit, q, n, 0) + circuit.cx(q[n-1],aux) + create_QFT(circuit,q,n,0) + cphiADD(circuit, q, aux, N, n, 0) + + ccphiADD(circuit, q, ctl1, ctl2, a, n, 1) + create_inverse_QFT(circuit, q, n, 0) + circuit.x(q[n-1]) + circuit.cx(q[n-1], aux) + circuit.x(q[n-1]) + create_QFT(circuit,q,n,0) + ccphiADD(circuit, q, ctl1, ctl2, a, n, 0) + +def ccphiADDmodN_inv(circuit, q, ctl1, ctl2, aux, a, N, n): + ccphiADD(circuit, q, ctl1, ctl2, a, n, 1) + create_inverse_QFT(circuit, q, n, 0) + circuit.x(q[n-1]) + circuit.cx(q[n-1],aux) + circuit.x(q[n-1]) + create_QFT(circuit, q, n, 0) + ccphiADD(circuit, q, ctl1, ctl2, a, n, 0) + cphiADD(circuit, q, aux, N, n, 1) + create_inverse_QFT(circuit, q, n, 0) + circuit.cx(q[n-1], aux) + create_QFT(circuit, q, n, 0) + phiADD(circuit, q, N, n, 0) + ccphiADD(circuit, q, ctl1, ctl2, a, n, 1) + +def cMULTmodN(circuit, ctl, q, aux, a, N, n): + create_QFT(circuit,aux,n+1,0) + for i in range(0, n): + ccphiADDmodN(circuit, aux, q[i], ctl, aux[n+1], (2**i)*a % N, N, n+1) + create_inverse_QFT(circuit, aux, n+1, 0) + + for i in range(0, n): + circuit.cswap(ctl,q[i],aux[i]) + + a_inv = modinv(a, N) + create_QFT(circuit, aux, n+1, 0) + i = n-1 + while i >= 0: + ccphiADDmodN_inv(circuit, aux, q[i], ctl, aux[n+1], pow(2,i)*a_inv % N, N, n+1) + i -= 1 + create_inverse_QFT(circuit, aux, n+1, 0) + +def get_value_a(N): + a=2 + while gcd(a,N)!=1: + a=a+1 + return a + + + +def factorize_number(N): + if N==1 or N==0: + print('Please put an N different from 0 and from 1') + exit() + + """ Check if N is even """ + + if (N%2)==0: + print('N is even, so does not make sense!') + exit() + + """ Check if N can be put in N=p^q, p>1, q>=2 """ + + """ Try all numbers for p: from 2 to sqrt(N) """ + if check_if_power(N)==True: + exit() + +# print('Not an easy case, using the quantum circuit is necessary\n') + + setup_IBM() + + """ Get an integer a that is coprime with N """ + a = get_value_a(N) + +# """ If user wants to force some values, he can do that here, please make sure to update the print and that N and a are coprime""" +# print('Forcing N=15 and a=4 because its the fastest case, please read top of source file for more info') +# N=15 +# a=4 + + print("help !!!") + """ Get n value used in Shor's algorithm, to know how many qubits are used """ + n = ceil(log(N,2)) + +# print('Total number of qubits used: {0}\n'.format(4*n+2)) + + aux = QuantumRegister(n+2) + up_reg = QuantumRegister(2*n) + down_reg = QuantumRegister(n) + up_classic = ClassicalRegister(2*n) + circuit = QuantumCircuit(down_reg , up_reg , aux, up_classic) + + circuit.h(up_reg) + circuit.x(down_reg[0]) + + """ Apply the multiplication gates as showed in the report in order to create the exponentiation """ + for i in range(0, 2*n): + cMULTmodN(circuit, up_reg[i], down_reg, aux, int(pow(a, pow(2, i))), N, n) + + """ Apply inverse QFT """ + create_inverse_QFT(circuit, up_reg, 2*n ,1) + + """ Measure the top qubits, to get x value""" + circuit.measure(up_reg,up_classic) + + """ Simulate the created Quantum Circuit """ +# print(transpile(circuit,BasicAer.get_backend('qasm_simulator'))) + #simulation = execute(circuit, backend=BasicAer.get_backend('qasm_simulator'),shots=number_shots) + provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main') + simulation = quantum_simulate(circuit,provider.get_backend('ibmq_lima'),True) + + i=0 + while i < len(simulation): + print('Result \"{0}\" happened {1} times out of {2}'.format(list(simulation.keys())[i],list(simulation.values())[i])) + i=i+1 + + """ An empty print just to have a good display in terminal """ + print(' ') + + """ Initialize this variable """ + # prob_success=0 + + """ For each simulation result, print proper info to user and try to calculate the factors of N""" + # i=0 + # while i < len(counts_result): + + #""" Get the x_value from the final state qubits """ + # output_desired = list(sim_result.get_counts().keys())[i] + # x_value = int(output_desired, 2) + # prob_this_result = 100 * ( int( list(sim_result.get_counts().values())[i] ) ) / (number_shots) + + #print("------> Analysing result {0}. This result happened in {1:.4f} % of all cases\n".format(output_desired,prob_this_result)) + + #""" Print the final x_value to user """ + # print('In decimal, x_final value for this result is: {0}\n'.format(x_value)) + + #""" Get the factors using the x value obtained """ + # success=get_factors(int(x_value),int(2*n),int(N),int(a)) + + #if success==True: + # prob_success = prob_success + prob_this_result + + #i=i+1 + +# print("\nUsing a={0}, found the factors of N={1} in {2:.4f} % of the cases\n".format(a,N,prob_success)) + +N = 33 +factorize_number(N) diff --git a/license b/license new file mode 100644 index 0000000..4ce7000 --- /dev/null +++ b/license @@ -0,0 +1,14 @@ +BSD Zero Clause License + +Copyright (c) 2023 Konrad Geletey + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. diff --git a/quantum_runner/__init__.py b/quantum_runner/__init__.py new file mode 100644 index 0000000..6e41b87 --- /dev/null +++ b/quantum_runner/__init__.py @@ -0,0 +1,31 @@ +from qiskit import execute,QuantumCircuit + +def quantum_simulate(circuit,backend,counts=False,shots=1024): + exe = execute(circuit,backend=backend,shots=shots) + if counts: + return exe.result().get_counts() + else: + return exe + +from dotenv import load_dotenv +#from pathlib import Path +from os import getenv + +from qiskit import IBMQ + +def setup_IBM(): + load_dotenv() + + # сохранить аккаунт + IBMQ.save_account(getenv('API_KEY'), overwrite=True) + IBMQ.load_account() + +from cirq import QasmOutput,Circuit,Qid +from typing import Tuple + +def cirq_qasm(circuit: 'Circuit'): + qasm_output = circuit.to_qasm() + return QuantumCircuit().from_qasm_str(str(qasm_output)) + + +#print(provider.backends())