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_qasm(self, QE_TOKEN, QE_URL):
"""counts from a GHZ state"""
register(QE_TOKEN, QE_URL)
q = qk.QuantumRegister(3)
c = qk.ClassicalRegister(3)
circ = qk.QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.cx(q[1], q[2])
circ.measure(q, c)
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
sim_ibmq = 'ibmq_qasm_simulator'
sim_hpc = 'ibmq_qasm_simulator_hpc'
shots = 2000
result_cpp = execute(circ, sim_cpp, {'shots': shots})
result_py = execute(circ, sim_py, {'shots': shots})
result_ibmq = execute(circ, sim_ibmq, {'shots': shots})
result_hpc = execute(circ, sim_hpc, {'shots': shots})
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
counts_ibmq = result_ibmq.get_counts()
counts_hpc = result_hpc.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.025)
self.assertDictAlmostEqual(counts_py, counts_ibmq, shots * 0.025)
self.assertDictAlmostEqual(counts_ibmq, counts_hpc, shots * 0.025)
def test_qasm_reset_measure(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""counts from a qasm program with measure and reset in the middle"""
register(QE_TOKEN, QE_URL, hub, group, project)
q = qiskit.QuantumRegister(3)
c = qiskit.ClassicalRegister(3)
circ = qiskit.QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.reset(q[0])
circ.cx(q[1], q[2])
circ.t(q)
circ.measure(q[1], c[1])
circ.h(q[2])
circ.measure(q[2], c[2])
# TODO: bring back online simulator tests when reset/measure doesn't
# get rejected by the api
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
# sim_ibmq = 'ibmq_qasm_simulator'
shots = 1000
result_cpp = execute(circ, sim_cpp, shots=shots, seed=1).result()
result_py = execute(circ, sim_py, shots=shots, seed=1).result()
# result_ibmq = execute(circ, sim_ibmq, {'shots': shots}).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
# counts_ibmq = result_ibmq.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.04)
def test_qasm_reset_measure(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None):
"""counts from a qasm program with measure and reset in the middle"""
register(QE_TOKEN, QE_URL, hub, group, project)
q = qiskit.QuantumRegister(3)
c = qiskit.ClassicalRegister(3)
circ = qiskit.QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.reset(q[0])
circ.cx(q[1], q[2])
circ.t(q)
circ.measure(q[1], c[1])
circ.h(q[2])
circ.measure(q[2], c[2])
# TODO: bring back online simulator tests when reset/measure doesn't
# get rejected by the api
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
# sim_ibmq = 'ibmq_qasm_simulator'
shots = 1000
result_cpp = execute(circ, sim_cpp, shots=shots, seed=1).result()
result_py = execute(circ, sim_py, shots=shots, seed=1).result()
# result_ibmq = execute(circ, sim_ibmq, {'shots': shots}).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
# counts_ibmq = result_ibmq.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.04)
def test_qasm_reset_measure(self, qe_token, qe_url):
"""counts from a qasm program with measure and reset in the middle"""
register(qe_token, qe_url)
qr = qiskit.QuantumRegister(3)
cr = qiskit.ClassicalRegister(3)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.reset(qr[0])
circuit.cx(qr[1], qr[2])
circuit.t(qr)
circuit.measure(qr[1], cr[1])
circuit.h(qr[2])
circuit.measure(qr[2], cr[2])
# TODO: bring back online simulator tests when reset/measure doesn't
# get rejected by the api
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
# sim_ibmq = 'ibmq_qasm_simulator'
shots = 1000
result_cpp = execute(circuit, sim_cpp, shots=shots, seed=1).result()
result_py = execute(circuit, sim_py, shots=shots, seed=1).result()
# result_ibmq = execute(circ, sim_ibmq, {'shots': shots}).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
# counts_ibmq = result_ibmq.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.04)
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 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 _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):
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_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 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_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_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 setUp(self):
wrapper.register(provider_class=SympyProvider)
qr = QuantumRegister(2, name="qr2")
cr = ClassicalRegister(2, name=None)
qc = QuantumCircuit(qr, cr, name="qc10")
qc.h(qr[0])
qc.measure(qr[0], cr[0])
self.qr_name = qr.name
self.cr_name = cr.name
self.circuits = [qc]
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 main():
parser = argparse.ArgumentParser(
description="Create randomized circuits for quantum volume analysis.")
parser.add_argument('--name',
default='quantum_volume',
help='circuit name')
parser.add_argument('-n',
'--qubits',
default=5,
type=int,
help='number of circuit qubits')
parser.add_argument('-d',
'--depth',
default=5,
type=int,
help='SU(4) circuit depth')
parser.add_argument('--num-circ',
default=1,
type=int,
help='how many circuits?')
parser.add_argument('-r',
'--run',
action='store_true',
help='execute circuit(s)')
parser.add_argument('-b',
'--backend',
default='local_qasm_simulator',
help='backend to execute on')
args = parser.parse_args()
circuits = build_model_circuits(n=args.qubits,
depth=args.depth,
num_circ=args.num_circ)
# Run the circuits
if args.run:
backend_name = args.backend
if backend_name.startswith("ibmq"):
import Qconfig
register(Qconfig.APItoken, Qconfig.config['url'])
result = execute(circuits, backend_name=backend_name)
print(result.get_counts(circuits[0]))
return
# Save QASM representation of circuits
for i in range(num_circ):
f = open('quantum_volume_n%d_d%d_i.qasm' % (n, depth, i), 'w')
f.write(circuits[i].qasm())
f.close()
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_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_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)
def test_qasm(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None):
"""counts from a GHZ state"""
register(QE_TOKEN, QE_URL, hub, group, project)
q = qiskit.QuantumRegister(3)
c = qiskit.ClassicalRegister(3)
circ = qiskit.QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.cx(q[1], q[2])
circ.measure(q, c)
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
sim_ibmq = 'ibmq_qasm_simulator'
shots = 2000
result_cpp = execute(circ, sim_cpp, shots=shots).result()
result_py = execute(circ, sim_py, shots=shots).result()
result_ibmq = execute(circ, sim_ibmq, shots=shots).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
counts_ibmq = result_ibmq.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots*0.05)
self.assertDictAlmostEqual(counts_py, counts_ibmq, shots*0.05)
def test_qasm(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None):
"""counts from a GHZ state"""
register(QE_TOKEN, QE_URL, hub, group, project)
q = qiskit.QuantumRegister(3)
c = qiskit.ClassicalRegister(3)
circ = qiskit.QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.cx(q[1], q[2])
circ.measure(q, c)
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
sim_ibmq = 'ibmq_qasm_simulator'
shots = 2000
result_cpp = execute(circ, sim_cpp, shots=shots).result()
result_py = execute(circ, sim_py, shots=shots).result()
result_ibmq = execute(circ, sim_ibmq, shots=shots).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
counts_ibmq = result_ibmq.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.05)
self.assertDictAlmostEqual(counts_py, counts_ibmq, shots * 0.05)
def test_qasm(self, qe_token, qe_url):
"""counts from a GHZ state"""
register(qe_token, qe_url)
qr = qiskit.QuantumRegister(3)
cr = qiskit.ClassicalRegister(3)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.measure(qr, cr)
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
sim_ibmq = 'ibmq_qasm_simulator'
shots = 2000
result_cpp = execute(circuit, sim_cpp, shots=shots).result()
result_py = execute(circuit, sim_py, shots=shots).result()
result_ibmq = execute(circuit, sim_ibmq, shots=shots).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
counts_ibmq = result_ibmq.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.05)
self.assertDictAlmostEqual(counts_py, counts_ibmq, shots * 0.05)
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)
def setUp(self):
wrapper.register(provider_class=SympyProvider)
self.qasm_filename = self._get_resource_path('simple.qasm')
self.q_circuit = load_qasm_file(self.qasm_filename)
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)
"""
Example showing how to use QISKit at level 0 (novice).
See level 1 if you would like to understand how to compile
Note: if you have only cloned the QISKit repository but not
used `pip install`, the examples only work from the root directory.
"""
# Import the QISKit modules
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, QISKitError
from qiskit.wrapper import available_backends, execute, register, get_backend
try:
import Qconfig
register(Qconfig.APItoken, Qconfig.config['url'])
except:
print("""WARNING: There's no connection with the API for remote backends.
Have you initialized a Qconfig.py file with your personal token?
For now, there's only access to local simulator 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'])
