def test_compact(self):
"""test the compact flag for available_backends works"""
compact_names = available_backends()
expanded_names = available_backends(compact=False)
self.assertIn('local_qasm_simulator', compact_names)
self.assertIn('local_statevector_simulator', compact_names)
self.assertIn('local_unitary_simulator', compact_names)
self.assertIn('local_qasm_simulator_py', expanded_names)
self.assertIn('local_statevector_simulator_py', expanded_names)
def test_compact(self):
"""test the compact flag for available_backends works"""
compact_names = available_backends()
expanded_names = available_backends(compact=False)
self.assertIn('local_qasm_simulator', compact_names)
self.assertIn('local_statevector_simulator', compact_names)
self.assertIn('local_unitary_simulator', compact_names)
self.assertIn('local_qasm_simulator_py', expanded_names)
self.assertIn('local_statevector_simulator_py', expanded_names)
def register_and_get_operational_backends(qconfig):
if qconfig is not None:
hub = qconfig.config.get('hub', None)
group = qconfig.config.get('group', None)
project = qconfig.config.get('project', None)
proxies = qconfig.config.get('proxies', None)
verify = qconfig.config.get('verify', True)
provider_name = qconfig.config.get('provider_name', 'ibmq')
try:
q_register(qconfig.APItoken,
qconfig.config["url"],
hub=hub,
group=group,
project=project,
proxies=proxies,
verify=verify,
provider_name=provider_name)
logger.debug('Registered with QISKit successfully.')
except Exception as e:
logger.debug('Failed to register quantum backends: {}'.format(
str(e)))
backends = available_backends()
backends = [
x for x in backends
if x not in QuantumAlgorithm.UNSUPPORTED_BACKENDS
]
return backends
def register_and_get_operational_backends(qconfig):
try:
for provider in q_registered_providers():
if isinstance(provider,IBMQProvider):
q_unregister(provider)
logger.debug("Provider 'IBMQProvider' unregistered with Qiskit successfully.")
break
except Exception as e:
logger.debug("Failed to unregister provider 'IBMQProvider' with Qiskit: {}".format(str(e)))
if qconfig is not None:
hub = qconfig.config.get('hub', None)
group = qconfig.config.get('group', None)
project = qconfig.config.get('project', None)
proxies = qconfig.config.get('proxies', None)
verify = qconfig.config.get('verify', True)
try:
q_register(qconfig.APItoken,
provider_class=IBMQProvider,
url=qconfig.config["url"],
hub=hub,
group=group,
project=project,
proxies=proxies,
verify=verify)
logger.debug("Provider 'IBMQProvider' registered with Qiskit successfully.")
except Exception as e:
logger.debug("Failed to register provider 'IBMQProvider' with Qiskit: {}".format(str(e)))
backends = available_backends()
backends = [x for x in backends if x not in QuantumAlgorithm.UNSUPPORTED_BACKENDS]
return backends
def test_compile_two_run_remote(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test Compiler and run two circuits.
If all correct some should exists.
"""
register(QE_TOKEN, QE_URL, hub, group, project)
backend = available_backends({'local': False, 'simulator': True})[0]
backend = get_backend(backend)
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qc_extra = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="extra")
qc_extra.measure(qubit_reg, clbit_reg)
qobj = transpiler.compile([qc, qc_extra], backend)
job = backend.run(qobj)
result = job.result()
self.assertIsInstance(result, Result)
def register_and_get_operational_backends(qconfig):
if qconfig is not None:
hub = qconfig.config.get('hub', None)
group = qconfig.config.get('group', None)
project = qconfig.config.get('project', None)
proxies = qconfig.config.get('proxies', None)
verify = qconfig.config.get('verify', True)
provider_name = qconfig.config.get('provider_name', 'ibmq')
try:
q_register(qconfig.APItoken,
qconfig.config["url"],
hub=hub,
group=group,
project=project,
proxies=proxies,
verify=verify,
provider_name=provider_name)
except:
logger.debug(
"WARNING: Can not register quantum backends. Check your Qconfig.py."
)
backends = available_backends()
backends = [
x for x in backends
if x not in QuantumAlgorithm.UNSUPPORTED_BACKENDS
]
return backends
def test_compile_two_remote(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test Compiler remote on two circuits.
If all correct some should exists.
"""
register(QE_TOKEN, QE_URL, hub, group, project)
backend = least_busy(available_backends())
backend = get_backend(backend)
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qc_extra = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="extra")
qc_extra.measure(qubit_reg, clbit_reg)
qobj = transpiler.compile([qc, qc_extra], backend)
# FIXME should test against the qobj when defined
self.assertEqual(len(qobj), 3)
def test_filter_config_dict(self, qe_token, qe_url):
"""Test filtering by dictionary of configuration properties"""
n_qubits = 20 if self.using_ibmq_credentials else 5
register(qe_token, qe_url)
filter_ = {'n_qubits': n_qubits, 'local': False}
filtered_backends = available_backends(filter_)
self.assertTrue(filtered_backends)
def lowest_pending_jobs():
"""Returns the backend with lowest pending jobs."""
list_of_backends = available_backends(
{'local': False, 'simulator': False})
device_status = [get_backend(backend).status for backend in list_of_backends]
best = min([x for x in device_status if x['available'] is True],
key=lambda x: x['pending_jobs'])
return best['name']
def test_filter_least_busy(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test filtering by least busy function"""
register(QE_TOKEN, QE_URL, hub, group, project)
filtered_backends = least_busy(available_backends())
self.assertTrue(filtered_backends)
def _get_backends(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None):
sim_backend = 'local_qasm_simulator'
try:
register(QE_TOKEN, QE_URL, hub, group, project)
real_backends = available_backends({'simulator': False})
real_backend = lowest_pending_jobs(real_backends)
except Exception:
real_backend = None
return sim_backend, real_backend
def _get_backends(self, qe_token, qe_url):
sim_backend = 'local_qasm_simulator'
try:
register(qe_token, qe_url)
real_backends = available_backends({'simulator': False})
real_backend = least_busy(real_backends)
except Exception:
real_backend = None
return sim_backend, real_backend
def _get_backends(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None):
sim_backend = 'local_qasm_simulator'
try:
register(QE_TOKEN, QE_URL, hub, group, project)
real_backends = available_backends({'simulator': False})
real_backend = lowest_pending_jobs(real_backends)
except Exception:
real_backend = None
return sim_backend, real_backend
def _get_backends(self, QE_TOKEN, QE_URL):
sim_backend = 'local_qasm_simulator'
try:
register(QE_TOKEN, QE_URL)
real_backends = available_backends({'simulator': False})
real_backend = least_busy(real_backends)
except Exception:
real_backend = None
return sim_backend, real_backend
def test_filter_status_config_dict(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test filtering by dictionary of mixed status/configuration properties"""
register(QE_TOKEN, QE_URL, hub, group, project)
filter_ = {'available': True, 'local': False, 'simulator': True}
filtered_backends = available_backends(filter_)
self.assertTrue(filtered_backends)
def test_filter_config_callable(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test filtering by lambda function on configuration properties"""
register(QE_TOKEN, QE_URL, hub, group, project)
filtered_backends = available_backends(lambda x: (not x.configuration[
'simulator'] and x.configuration['n_qubits'] > 5))
self.assertTrue(filtered_backends)
def test_filter_config_dict(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test filtering by dictionary of configuration properties"""
register(QE_TOKEN, QE_URL, hub, group, project)
filter_ = {'n_qubits': 5, 'local': False}
filtered_backends = available_backends(filter_)
self.assertTrue(filtered_backends)
def test_remote_result_fields(self, qe_token, qe_url):
"""Test components of a result from a remote simulator."""
register(qe_token, qe_url)
remote_backend = available_backends({
'local': False,
'simulator': True
})[0]
remote_result = execute(self._qc1, remote_backend).result()
self.assertEqual(remote_result.backend_name, remote_backend)
self.assertIsInstance(remote_result.job_id, str)
self.assertEqual(remote_result.status, 'COMPLETED')
self.assertEqual(remote_result.circuit_statuses(), ['DONE'])
def test_execute_remote(self, qe_token, qe_url):
"""Test Execute remote.
If all correct some should exists.
"""
register(qe_token, qe_url)
backend = available_backends({'local': False, 'simulator': True})[0]
backend = get_backend(backend)
qubit_reg = qiskit.QuantumRegister(2)
clbit_reg = qiskit.ClassicalRegister(2)
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg)
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
job = execute(qc, backend, seed=TestCompiler.seed)
results = job.result()
self.assertIsInstance(results, Result)
def test_execute_remote(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None):
"""Test Execute remote.
If all correct some should exists.
"""
register(QE_TOKEN, QE_URL, hub, group, project)
backend = available_backends({'local': False, 'simulator': True})[0]
backend = get_backend(backend)
qubit_reg = qiskit.QuantumRegister(2)
clbit_reg = qiskit.ClassicalRegister(2)
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg)
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
job = execute(qc, backend)
results = job.result()
self.assertIsInstance(results, Result)
def test_compile_run_remote(self, qe_token, qe_url):
"""Test Compiler and run remote.
If all correct some should exists.
"""
register(qe_token, qe_url)
backend = available_backends({'local': False, 'simulator': True})[0]
backend = get_backend(backend)
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qobj = transpiler.compile(qc, backend, seed=TestCompiler.seed)
job = backend.run(qobj)
result = job.result(timeout=20)
self.assertIsInstance(result, Result)
def test_compile_remote(self, qe_token, qe_url):
"""Test Compiler remote.
If all correct some should exists.
"""
register(qe_token, qe_url)
backend = least_busy(available_backends())
backend = get_backend(backend)
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qobj = transpiler.compile(qc, backend)
# FIXME should validate the Qobj when defined
self.assertIsInstance(qobj, Qobj)
clbit_reg = ClassicalRegister(2, name='c')
# Making first circuit: bell state
qc1 = QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc1.h(qubit_reg[0])
qc1.cx(qubit_reg[0], qubit_reg[1])
qc1.measure(qubit_reg, clbit_reg)
# Making another circuit: superpositions
qc2 = QuantumCircuit(qubit_reg, clbit_reg, name="superposition")
qc2.h(qubit_reg)
qc2.measure(qubit_reg, clbit_reg)
# Setting up the backend
print("(Local Backends)")
for backend_name in available_backends({'local': True}):
backend = get_backend(backend_name)
print(backend.status)
my_backend_name = 'local_qasm_simulator'
my_backend = get_backend(my_backend_name)
print("(Local QASM Simulator configuration) ")
pprint.pprint(my_backend.configuration)
print("(Local QASM Simulator calibration) ")
pprint.pprint(my_backend.calibration)
print("(Local QASM Simulator parameters) ")
pprint.pprint(my_backend.parameters)
# Compiling the job
qobj = compile([qc1, qc2], my_backend)
# I think we need to make a qobj into a class
q = QuantumRegister(2)
# Create a Classical Register with 2 bits.
c = ClassicalRegister(2)
# Create a Quantum Circuit
qc = QuantumCircuit(q, c)
# Add a H gate on qubit 0, putting this qubit in superposition.
qc.h(q[0])
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
qc.cx(q[0], q[1])
# Add a Measure gate to see the state.
qc.measure(q, c)
# See a list of available local simulators
print("Local backends: ", available_backends({'local': True}))
# Compile and run the Quantum circuit on a simulator backend
sim_result = execute(qc, "local_qasm_simulator")
# Show the results
print("simulation: ", sim_result)
print(sim_result.get_counts(qc))
# see a list of available remote backends
remote_backends = available_backends({'local': False, 'simulator': False})
print("Remote backends: ", remote_backends)
# Compile and run the Quantum Program on a real device backend
try:
best_device = lowest_pending_jobs()
def test_filter_status_config_dict(self, qe_token, qe_url):
"""Test filtering by dictionary of mixed status/configuration properties"""
register(qe_token, qe_url)
filter_ = {'operational': True, 'local': False, 'simulator': True}
filtered_backends = available_backends(filter_)
self.assertTrue(filtered_backends)
def test_filter_config_callable(self, qe_token, qe_url):
"""Test filtering by lambda function on configuration properties"""
register(qe_token, qe_url)
filtered_backends = available_backends(lambda x: (not x.configuration()['simulator'] and
x.configuration()['n_qubits'] > 5))
self.assertTrue(filtered_backends)
def test_filter_least_busy(self, qe_token, qe_url):
"""Test filtering by least busy function"""
register(qe_token, qe_url)
filtered_backends = least_busy(available_backends())
self.assertTrue(filtered_backends)
clbit_reg = ClassicalRegister(2)
# making first circuit: bell state
qc1 = QuantumCircuit(qubit_reg, clbit_reg)
qc1.h(qubit_reg[0])
qc1.cx(qubit_reg[0], qubit_reg[1])
qc1.measure(qubit_reg, clbit_reg)
# making another circuit: superpositions
qc2 = QuantumCircuit(qubit_reg, clbit_reg)
qc2.h(qubit_reg)
qc2.measure(qubit_reg, clbit_reg)
# setting up the backend
print("(Local Backends)")
print(available_backends({'local': True}))
# runing the job
sim_result = execute([qc1, qc2], "local_qasm_simulator")
# Show the results
print("simulation: ", sim_result)
print(sim_result.get_counts(qc1))
print(sim_result.get_counts(qc2))
# see a list of available remote backends
print("\n(Remote Backends)")
print(available_backends({'local': False}))
# Compile and run on a real device backend
try:
def test_filter_least_busy(self, QE_TOKEN, QE_URL):
"""Test filtering by least busy function"""
register(QE_TOKEN, QE_URL)
filtered_backends = least_busy(available_backends())
self.assertTrue(filtered_backends)