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 _shors_period_finder(self, job_descriptor: ShorJobDescriptor, fleet: QFleet, shots=None):
key = str(job_descriptor)
self.logger.debug("Constructing circuit for Shor's algorithm on {}".format(key))
self._update_status(job_descriptor,
status=QStatus.CONSTRUCTING_CIRCUIT)
n = job_descriptor.n
a = job_descriptor.a
shor = Shor(N=n, a=a)
circ = shor.construct_circuit(measurement=True)
self.logger.debug("Constructed circuit for {}, finding backend...".format(key))
self._update_status(job_descriptor,
status=QStatus.FINDING_BACKEND)
qcomp = fleet.get_best_backend(circ.n_qubits, job_descriptor.allow_simulator)
if not qcomp:
raise QNoBackendException("No viable backend with {} qubits for job {}".format(circ.n_qubits, key))
self.logger.debug("Got backend '{}' for job {}. Executing...".format(qcomp.name(), key))
self._update_status(job_descriptor,
status=QStatus.REQUEST_EXECUTE,
backend=qcomp)
kwargs = {'backend': qcomp}
if shots:
kwargs['shots'] = shots
job = execute(circ, **kwargs)
self.logger.debug("Started job {}, status is {}".format(key, job.status()))
self._update_status_by_job(job_descriptor, job, circ)
return job, circ
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 shor_circuit():
"""
Builds A QuantumCircuit object of shor's algorithm implementation
found in qiskit aqua
Args:
Returns:
Resulting circuit of the qiskit aqua implementation of Shor's
algorithm after adding measures on every qubit.
"""
shor = Shor()
circ = shor.construct_circuit()
return add_measures(circ)
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)
def run_shor(N):
if N <= 64: #Arbitrarily set upper limit for local simulator
print("Getting local simulator backend...")
backend = Aer.get_backend('qasm_simulator')
else:
print("Getting provider...")
if not IBMQ.active_account():
IBMQ.load_account()
provider = IBMQ.get_provider()
print("Getting IBM Q simulator backend...")
backend = provider.get_backend('ibmq_qasm_simulator')
print("Running Shor's algorithm for", str(N), "on", backend, "...")
results = Shor(N=N).run(backend)
print("\nResults:")
if results['factors'] == []:
print("No prime factors: ", str(N), "=", str(N))
elif isinstance(results['factors'][0], int):
print("Prime factors: ", str(N), "=", results['factors'][0], "^ 2")
else:
print("Prime factors: ", str(N), "=", results['factors'][0][0], "*",
results['factors'][0][1])
def test_shor_bad_input(self, N):
with self.assertRaises(AquaError):
Shor(N)
def display_shor(N):
print("Building Shor circuit...")
shor_circuit = Shor(N=N).construct_circuit()
print(shor_circuit)
print("Circuit data\n\nDepth: ", shor_circuit.depth(), "\nWidth: ",
shor_circuit.width(), "\nSize: ", shor_circuit.size())
import logging
import os
from qiskit.aqua.algorithms import Shor
from definitions import OUTPUT_DIR
logging.basicConfig(format="%(message)s", level=logging.INFO)
logger = logging.getLogger(__name__)
Ns = 15, 21, 39
for N in Ns:
logging.info("\nShor's circuit configuration for factoring {}:".format(N))
shor = Shor(N)
qc = shor.construct_circuit()
qc.draw(output='latex_source',
filename=(os.path.join(OUTPUT_DIR,
'shors-diag-for-{}.tex'.format(N))))
num_qubits = qc.num_qubits
num_classical_bits = qc.num_clbits
# get the number and type of the gates in circuit
num_ops = qc.count_ops()
# get just the raw count of operations by computing the circuits size
size = qc.size()
'''The depth of a quantum circuit is a measure of how many "layers" of quantum gates, executed in parallel,
it takes to complete the computation defined by the circuit. Because quantum gates take time to implement,
the depth of a circuit roughly corresponds to the amount of time it takes the quantum computer to execute the
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 IBMQ, Aer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
# provider = IBMQ.load_account()
IBMQ.enable_account(
'2c48804aa2f1d7c872f4cb2a37a4ec649f24241766d16c4b81061b00f62c2f0419dd04f260fe59be8a9550a93bea7692fa956cc6637565b593ae98e29c77331c'
)
provider = IBMQ.get_provider(hub='ibm-q')
# backend = provider.get_backend('ibmq_qasm_simulator') # Specifies the quantum device
backend = Aer.get_backend('qasm_simulator')
# backend = provider.get_backend('ibmq_16_melbourne') # using quantum backend
print('\n Shors Algorithm')
print('--------------------')
print('\nExecuting...\n')
factors = Shor(21) #Function to run Shor's algorithm
result_dict = factors.run(
QuantumInstance(backend, shots=10, skip_qobj_validation=False))
result = result_dict['factors'] # Get factors from results
print(result)
for q in range(2*n):
(c_amod15(qc, a, 2**q, 2*n),[q] + [i+2*n for i in range(n)])
InverseQFT(qc,2*n,0)
qc.measure(q,c)
qc.draw()
# In[36]:
from qiskit.aqua.algorithms import Shor
a, N = 2, 3
shor = Shor(N, a)
circuit = shor.construct_circuit()
#print(circuit.draw())
#circuit.draw(output='mpl')
# In[ ]:
#U2, U1, U3
# In[49]:
#Conditional Phase Shift
"""
from qiskit import IBMQ
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
"""Connect IBM Quantum Computer"""
# Enter your API token here
IBMQ.enable_account('ENTER API TOKEN HERE')
provider = IBMQ.get_provider(hub='ibm-q')
# Specifies the quantum device
backend = provider.get_backend('ibmq_qasm_simulator')
"""Factorize first number"""
first_factors = Shor(571)
result_dict = first_factors.run(
QuantumInstance(backend, shots=1, skip_qobj_validation=False))
# Get factors from results
first_result = result_dict['first_factors']
print(first_result)
"""Factorize second number"""
second_factors = Shor(757)
result_dict = second_factors.run(
QuantumInstance(backend, shots=1, skip_qobj_validation=False))
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 test_logging_emit(self):
""" logging emit test """
with self.assertLogs(QiskitLogDomains.DOMAIN_AQUA.value,
level='INFO') as log:
_ = Shor(int(math.pow(3, 5)))
self.assertIn('The input integer is a power:', log.output[0])
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)
def test_shor_modinv(self, a_v, m_v, expected):
""" shor modular inverse test """
modinv = Shor.modinv(a_v, m_v)
self.assertTrue(modinv == expected)
from qiskit import IBMQ
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
IBMQ.enable_account('ENTER API TOKEN HERE') # 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))
result = result_dict['factors'] # Get factors from results
print(result)
print('\nPress any key to close')
input()
def test_shor_bad_input(self, n_v):
""" shor bad input test """
with self.assertRaises(AquaError):
Shor(n_v)
"""
@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
