def test_shor_power(self, base, power):
N = int(math.pow(base, power))
shor = Shor(N)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
ret = shor.run(quantum_instance)
self.assertTrue(ret['factors'] == [base])
def test_shor_no_factors(self, n_v):
""" shor no factors test """
shor = Shor(n_v)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
ret = shor.run(quantum_instance)
self.assertTrue(ret['factors'] == [])
def test_shor_factoring(self, n_v, backend, factors):
""" shor factoring test """
shor = Shor(n_v)
result_dict = shor.run(
QuantumInstance(BasicAer.get_backend(backend), shots=1000))
self.assertListEqual(result_dict['factors'][0], factors)
self.assertTrue(
result_dict["total_counts"] >= result_dict["successful_counts"])
def test_shor_power(self, base, power):
""" shor power test """
n_v = int(math.pow(base, power))
shor = Shor(n_v)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
ret = shor.run(quantum_instance)
self.assertTrue(ret['factors'] == [base])
self.assertTrue(ret["total_counts"] >= ret["successful_counts"])
def factorize(self):
shor = Shor(self.factor)
# If you use get_backend('qasm_simulator') don't factor numbers greater than 15, it lasts nearly forever
backend = BasicAer.get_backend('qasm_simulator')
print(f"Using backend: {backend}")
quantum_instance = QuantumInstance(backend, shots=1)
computation = shor.run(quantum_instance)
if len(computation['factors']) == 0:
print("Algorithm went wrong")
return None, None
result = computation['factors'][0]
return result[0], result[1]
def factorize(self):
shor = Shor(self.factor)
device = least_busy(
self.__provider.backends(
filters=lambda x: x.configuration().n_qubits >= 3 and not x.
configuration().simulator and x.status().operational == True))
print("Running on current least busy device: ", device)
quantum_instance = QuantumInstance(device,
shots=1024,
skip_qobj_validation=False)
computation = shor.run(quantum_instance)
if len(computation['factors']) == 0:
print("Algorithm went wrong")
return None, None
result = computation['factors'][0]
return result[0], result[1]
def main():
def tadaa(string):
print(string)
def incoming(string):
input(string)
API = "26f2e1b4b40ea8d23675f7c644437f38a7b16ba89d09963345b4549c37763401e9a00aa81041e9d3f560c71cb24c1d02a6c142f2cac3d6fa668f786c0e467e49"
IBMQ.enable_account(API)
provider = IBMQ.get_provider(hub="ibm-q")
backend = provider.get_backend("ibmq_qasm_simulator")
tadaa("\n Shor Algorithm")
tadaa("\n --------------")
tadaa("\n Executing.....")
factors = Shor(21)
result_dict = factors.run(
QuantumInstance(backend, shots=1, skip_qobj_validation=False))
result = result_dict['factors'] # Get factors from results
tadaa(result)
tadaa("\n Press any ket to close.")
incoming()
def run_shor():
token = 'e22b17863fe0ab0a707122dd9aeec8b0f99aaed329dd8639ed5d0dab947d0170e7331df51167088e51c4be2266ee0933ce41624392b14a84b9076c0d72325d66'
IBMQ.enable_account(token) # Enter your API token here
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend(
'ibmq_qasm_simulator') # Specifies the quantum device
print('\n Shors Algorithm')
print('--------------------')
print('\nExecuting...\n')
factors = Shor(
21
) # Function to run Shor's algorithm where 21 is the integer to be factored
result_dict = factors.run(
QuantumInstance(backend, shots=1, skip_qobj_validation=False))
print(result_dict)
import logging
from qiskit import Aer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
logging.basicConfig(format="'%(asctime)s' %(name)s %(message)s'",
level=logging.INFO)
logger = logging.getLogger('main')
# provider = IBMQ.load_account()
# device = provider.get_backend('ibmq_qasm_simulator')
device = Aer.get_backend('qasm_simulator')
number_to_factorize = 15
shor = Shor(number_to_factorize)
quantum_instance = QuantumInstance(device)
result = shor.run(quantum_instance)
print("The list of factors of {} as computed by Shor is {}.".format(
number_to_factorize, result['factors'][0]))
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance, run_algorithm
from qiskit.aqua.algorithms import Shor
n = int(input("Enter the number: "))
shor = Shor(n)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,shots=2000)
res = shor.run(quantum_instance)
fact = res['factors'][0]
print(f" Factors of { n } using Shor's Algorithm is: {fact}")
# -*- coding: utf-8 -*-
"""
Created on Fri Apr 24 21:06:08 2020
@author: Neil Gupte
"""
from qiskit import IBMQ
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
IBMQ.enable_account( ' aditya replace your token here 52b916f6b6934d0ff3a5754d98217dc1862bcb88cc04acc77147936d166cb28f67d4f60d6fd492b7') # Enter your API token here
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator') # Specifies the quantum device
print('\n Shors Algorithm')
print('--------------------')
print('\nExecuting...\n')
factors = Shor(15) #Function to run Shor's algorithm where 21 is the integer to be factored
result_dict = factors.run(QuantumInstance(backend, shots=1, skip_qobj_validation=False))
result = result_dict['factors'] # Get factors from results
print(result)
print('\nPress any key to close')
circuit =Shor.construct_circuit() #check if we show the circuit by any means there is a circuit available on ibmq dashboard but it is too large to display see if there is a way to show that circuit
circuit.draw()
def callQuantumFactor():
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
my_shor = Shor(N=15,a=2,quantum_instance=quantum_instance)
return Shor.run(my_shor)
"""
@author: KhomZ
@kyzen khom
"""
from qiskit.aqua.algorithms import Shor
from qiskit.aqua import QuantumInstance
from qiskit import Aer
key = 21 # no. to factor
base = 2
backend = Aer.get_backend('qasm_simulator')
qi = QuantumInstance(backend=backend, shots=1024)
shors = Shor(N=key, a=base, quantum_instance=qi)
results = shors.run()
print(result['factors'])
@ikhomkodes