def test_run_program_map(self):
"""Test run_program_map.
If all correct should return 10010.
"""
QP_program = QuantumProgram()
QP_program.set_api(API_TOKEN, URL)
backend = 'local_qasm_simulator' # the backend to run on
shots = 100 # the number of shots in the experiment.
max_credits = 3
coupling_map = {0: [1], 1: [2], 2: [3], 3: [4]}
initial_layout = {
("q", 0): ("q", 0),
("q", 1): ("q", 1),
("q", 2): ("q", 2),
("q", 3): ("q", 3),
("q", 4): ("q", 4)
}
QP_program.load_qasm_file(QASM_FILE_PATH_2, name="circuit-dev")
circuits = ["circuit-dev"]
qobj = QP_program.compile(circuits,
backend=backend,
shots=shots,
max_credits=max_credits,
seed=65,
coupling_map=coupling_map,
initial_layout=initial_layout)
result = QP_program.run(qobj)
self.assertEqual(result.get_counts("circuit-dev"), {'10010': 100})
def test_json_output(self):
qp = QuantumProgram()
qp.load_qasm_file(self.QASM_FILE_PATH, name="example")
basis_gates = [] # unroll to base gates, change to test
unroller = unroll.Unroller(qasm.Qasm(data=qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
self.log.info('test_json_ouptut: %s', circuit)
def test_json_output(self):
qprogram = QuantumProgram()
qprogram.load_qasm_file(self.qasm_file_path, name="example")
basis_gates = [] # unroll to base gates, change to test
unroller = unroll.Unroller(qasm.Qasm(data=qprogram.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
self.log.info('test_json_ouptut: %s', circuit)
def test_json_output(self):
seed = 88
qp = QuantumProgram()
qp.load_qasm_file(self.QASM_FILE_PATH, name="example")
basis_gates = [] # unroll to base gates, change to test
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
logging.info('test_json_ouptut: {0}'.format(circuit))
class LocalQasmSimulatorTest(QiskitTestCase):
"""Test local qasm simulator."""
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/simple.qasm')
self.qp = QuantumProgram()
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
circuit_config = {
'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': self.seed
}
resources = {'max_credits': 3, 'wait': 5, 'timeout': 120}
self.qobj = {
'id':
'test_sim_single_shot',
'config': {
'max_credits': resources['max_credits'],
'shots': 1024,
'backend': 'local_sympy_qasm_simulator',
},
'circuits': [{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': None,
'config': circuit_config
}]
}
self.q_job = QuantumJob(self.qobj,
backend='local_sympy_qasm_simulator',
circuit_config=circuit_config,
seed=self.seed,
resources=resources,
preformatted=True)
def test_qasm_simulator(self):
"""Test data counts output for single circuit run against reference."""
result = SympyQasmSimulator().run(self.q_job)
actual = result.get_data('test')['quantum_state']
self.assertEqual(result.get_status(), 'COMPLETED')
self.assertEqual(actual[0], sqrt(2) / 2)
self.assertEqual(actual[1], 0)
self.assertEqual(actual[2], 0)
self.assertEqual(actual[3], sqrt(2) / 2)
def use_sympy_backends():
qprogram = QuantumProgram()
current_dir = os.path.dirname(os.path.realpath(__file__))
qasm_file = current_dir + "/../qasm/simple.qasm"
qasm_circuit = qprogram.load_qasm_file(qasm_file)
print("analyzing: " + qasm_file)
print(qprogram.get_qasm(qasm_circuit))
# sympy statevector simulator
backend = 'local_sympy_qasm_simulator'
result = qprogram.execute([qasm_circuit],
backend=backend,
shots=1,
timeout=300)
print("final quantum amplitude vector: ")
print(result.get_data(qasm_circuit)['quantum_state'])
# sympy unitary simulator
backend = 'local_sympy_unitary_simulator'
result = qprogram.execute([qasm_circuit],
backend=backend,
shots=1,
timeout=300)
print("\nunitary matrix of the circuit: ")
print(result.get_data(qasm_circuit)['unitary'])
class MapperTest(QiskitTestCase):
"""Test the mapper."""
def setUp(self):
self.seed = 42
self.qp = QuantumProgram()
def tearDown(self):
pass
def test_mapper_overoptimization(self):
"""
The mapper should not change the semantics of the input. An overoptimization introduced
the issue #81: https://github.com/QISKit/qiskit-sdk-py/issues/81
"""
self.qp.load_qasm_file(
self._get_resource_path('qasm/overoptimization.qasm'), name='test')
coupling_map = {0: [2], 1: [2], 2: [3], 3: []}
result1 = self.qp.execute(["test"],
backend="local_qasm_simulator",
coupling_map=coupling_map)
count1 = result1.get_counts("test")
result2 = self.qp.execute(["test"],
backend="local_qasm_simulator",
coupling_map=None)
count2 = result2.get_counts("test")
self.assertEqual(
count1.keys(),
count2.keys(),
)
def test_math_domain_error(self):
"""
The math library operates over floats and introduce floating point errors that should be avoid
See: https://github.com/QISKit/qiskit-sdk-py/issues/111
"""
self.qp.load_qasm_file(
self._get_resource_path('qasm/math_domain_error.qasm'),
name='test')
coupling_map = {0: [2], 1: [2], 2: [3], 3: []}
result1 = self.qp.execute(["test"],
backend="local_qasm_simulator",
coupling_map=coupling_map,
seed=self.seed)
self.assertEqual(result1.get_counts("test"), {
'0001': 507,
'0101': 517
})
class StatevectorSimulatorSympyTest(QiskitTestCase):
"""Test local statevector simulator."""
def setUp(self):
self.qasm_filename = self._get_resource_path('qasm/simple.qasm')
self.qp = QuantumProgram()
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
circuit_config = {'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None}
resources = {'max_credits': 3}
self.qobj = {'id': 'test_sim_single_shot',
'config': {
'max_credits': resources['max_credits'],
'shots': 1024,
'backend_name': 'local_statevector_simulator_sympy',
},
'circuits': [
{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': None,
'config': circuit_config
}
]}
self.q_job = QuantumJob(self.qobj,
backend=StatevectorSimulatorSympy(),
circuit_config=circuit_config,
resources=resources,
preformatted=True)
def test_statevector_simulator_sympy(self):
"""Test data counts output for single circuit run against reference."""
result = StatevectorSimulatorSympy().run(self.q_job).result()
actual = result.get_data('test')['statevector']
self.assertEqual(result.get_status(), 'COMPLETED')
self.assertEqual(actual[0], sqrt(2)/2)
self.assertEqual(actual[1], 0)
self.assertEqual(actual[2], 0)
self.assertEqual(actual[3], sqrt(2)/2)
def test_execute_program_map(self):
"""Test execute_program_map.
If all correct should return 10010.
"""
QP_program = QuantumProgram()
QP_program.set_api(API_TOKEN, URL)
backend = 'local_qasm_simulator' # the backend to run on
shots = 100 # the number of shots in the experiment.
max_credits = 3
coupling_map = {0: [1], 1: [2], 2: [3], 3: [4]}
initial_layout = {("q", 0): ("q", 0), ("q", 1): ("q", 1),
("q", 2): ("q", 2), ("q", 3): ("q", 3),
("q", 4): ("q", 4)}
QP_program.load_qasm_file(QASM_FILE_PATH_2, "circuit-dev")
circuits = ["circuit-dev"]
result = QP_program.execute(circuits, backend=backend, shots=shots,
max_credits=max_credits,
coupling_map=coupling_map,
initial_layout=initial_layout, seed=5455)
self.assertEqual(result.get_counts("circuit-dev"), {'10010': 100})
def test_load_qasm_file(self):
"""Test load_qasm_file and get_circuit.
If all is correct we should get the qasm file loaded in QASM_FILE_PATH
Previusly:
Libraries:
from qiskit import QuantumProgram
"""
QP_program = QuantumProgram()
name = QP_program.load_qasm_file(QASM_FILE_PATH, name="",
verbose=False)
result = QP_program.get_circuit(name)
to_check = result.qasm()
# print(to_check)
self.assertEqual(len(to_check), 554)
def test_load_qasm_file(self):
"""Test load_qasm_file and get_circuit.
If all is correct we should get the qasm file loaded in QASM_FILE_PATH
Previusly:
Libraries:
from qiskit import QuantumProgram
"""
QP_program = QuantumProgram()
name = QP_program.load_qasm_file(QASM_FILE_PATH, name="",
verbose=False)
result = QP_program.get_circuit(name)
to_check = result.qasm()
# print(to_check)
self.assertEqual(len(to_check), 554)
def use_sympy_backends():
qprogram = QuantumProgram()
current_dir = os.path.dirname(os.path.realpath(__file__))
qasm_file = current_dir + "/../qasm/simple.qasm"
qasm_circuit = qprogram.load_qasm_file(qasm_file)
print("analyzing: " + qasm_file)
print(qprogram.get_qasm(qasm_circuit))
# sympy statevector simulator
backend = 'local_statevector_simulator_sympy'
result = qprogram.execute([qasm_circuit], backend=backend, shots=1, timeout=300)
print("final quantum amplitude vector: ")
print(result.get_data(qasm_circuit)['statevector'])
# sympy unitary simulator
backend = 'local_unitary_simulator_sympy'
result = qprogram.execute([qasm_circuit], backend=backend, shots=1, timeout=300)
print("\nunitary matrix of the circuit: ")
print(result.get_data(qasm_circuit)['unitary'])
def execute(argv, verbose=False):
from qiskit import QuantumProgram
# Create the quantum program
qp = QuantumProgram()
# Load from filename
circuit = qp.load_qasm_file(filename)
# Get qasm source
source = qp.get_qasm(circuit)
if verbose:
print(source)
# Compile and run
backend = 'local_qasm_simulator'
qobj = qp.compile([circuit], backend) # Compile your program
result = qp.run(qobj, wait=2, timeout=240)
if verbose:
print(result)
print(result.get_counts(circuit))
class TestLocalQasmSimulatorPy(QiskitTestCase):
"""Test local_qasm_simulator_py."""
@classmethod
def setUpClass(cls):
super().setUpClass()
if do_profiling:
cls.pdf = PdfPages(cls.moduleName + '.pdf')
@classmethod
def tearDownClass(cls):
if do_profiling:
cls.pdf.close()
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/example.qasm')
self.qp = QuantumProgram()
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
circuit_config = {
'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': self.seed
}
resources = {'max_credits': 3}
self.qobj = {
'id':
'test_sim_single_shot',
'config': {
'max_credits': resources['max_credits'],
'shots': 1024,
'backend_name': 'local_qasm_simulator_py',
},
'circuits': [{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': None,
'config': circuit_config
}]
}
self.q_job = QuantumJob(self.qobj,
backend=QasmSimulatorPy(),
circuit_config=circuit_config,
seed=self.seed,
resources=resources,
preformatted=True)
def tearDown(self):
pass
def test_qasm_simulator_single_shot(self):
"""Test single shot run."""
shots = 1
self.qobj['config']['shots'] = shots
result = QasmSimulatorPy().run(self.q_job).result()
self.assertEqual(result.get_status(), 'COMPLETED')
def test_qasm_simulator(self):
"""Test data counts output for single circuit run against reference."""
result = QasmSimulatorPy().run(self.q_job).result()
shots = 1024
threshold = 0.04 * shots
counts = result.get_counts('test')
target = {
'100 100': shots / 8,
'011 011': shots / 8,
'101 101': shots / 8,
'111 111': shots / 8,
'000 000': shots / 8,
'010 010': shots / 8,
'110 110': shots / 8,
'001 001': shots / 8
}
self.assertDictAlmostEqual(counts, target, threshold)
def test_if_statement(self):
self.log.info('test_if_statement_x')
shots = 100
max_qubits = 3
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', max_qubits)
cr = qp.create_classical_register('cr', max_qubits)
circuit_if_true = qp.create_circuit('test_if_true', [qr], [cr])
circuit_if_true.x(qr[0])
circuit_if_true.x(qr[1])
circuit_if_true.measure(qr[0], cr[0])
circuit_if_true.measure(qr[1], cr[1])
circuit_if_true.x(qr[2]).c_if(cr, 0x3)
circuit_if_true.measure(qr[0], cr[0])
circuit_if_true.measure(qr[1], cr[1])
circuit_if_true.measure(qr[2], cr[2])
circuit_if_false = qp.create_circuit('test_if_false', [qr], [cr])
circuit_if_false.x(qr[0])
circuit_if_false.measure(qr[0], cr[0])
circuit_if_false.measure(qr[1], cr[1])
circuit_if_false.x(qr[2]).c_if(cr, 0x3)
circuit_if_false.measure(qr[0], cr[0])
circuit_if_false.measure(qr[1], cr[1])
circuit_if_false.measure(qr[2], cr[2])
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_true')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit_true = unroller.execute()
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_false')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit_false = unroller.execute()
qobj = {
'id':
'test_if_qobj',
'config': {
'max_credits': 3,
'shots': shots,
'backend_name': 'local_qasm_simulator_py',
},
'circuits': [{
'name': 'test_if_true',
'compiled_circuit': ucircuit_true,
'compiled_circuit_qasm': None,
'config': {
'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': None
}
}, {
'name': 'test_if_false',
'compiled_circuit': ucircuit_false,
'compiled_circuit_qasm': None,
'config': {
'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': None
}
}]
}
q_job = QuantumJob(qobj, backend=QasmSimulatorPy(), preformatted=True)
result = QasmSimulatorPy().run(q_job).result()
result_if_true = result.get_data('test_if_true')
self.log.info('result_if_true circuit:')
self.log.info(circuit_if_true.qasm())
self.log.info('result_if_true=%s', result_if_true)
result_if_false = result.get_data('test_if_false')
self.log.info('result_if_false circuit:')
self.log.info(circuit_if_false.qasm())
self.log.info('result_if_false=%s', result_if_false)
self.assertTrue(result_if_true['counts']['111'] == 100)
self.assertTrue(result_if_false['counts']['001'] == 100)
@unittest.skipIf(version_info.minor == 5,
"Due to gate ordering issues with Python 3.5 \
we have to disable this test until fixed"
)
def test_teleport(self):
"""test teleportation as in tutorials"""
self.log.info('test_teleport')
pi = np.pi
shots = 1000
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 3)
cr0 = qp.create_classical_register('cr0', 1)
cr1 = qp.create_classical_register('cr1', 1)
cr2 = qp.create_classical_register('cr2', 1)
circuit = qp.create_circuit('teleport', [qr], [cr0, cr1, cr2])
circuit.h(qr[1])
circuit.cx(qr[1], qr[2])
circuit.ry(pi / 4, qr[0])
circuit.cx(qr[0], qr[1])
circuit.h(qr[0])
circuit.barrier(qr)
circuit.measure(qr[0], cr0[0])
circuit.measure(qr[1], cr1[0])
circuit.z(qr[2]).c_if(cr0, 1)
circuit.x(qr[2]).c_if(cr1, 1)
circuit.measure(qr[2], cr2[0])
backend = 'local_qasm_simulator_py'
qobj = qp.compile('teleport',
backend=backend,
shots=shots,
seed=self.seed)
results = qp.run(qobj)
data = results.get_counts('teleport')
alice = {}
bob = {}
alice['00'] = data['0 0 0'] + data['1 0 0']
alice['01'] = data['0 1 0'] + data['1 1 0']
alice['10'] = data['0 0 1'] + data['1 0 1']
alice['11'] = data['0 1 1'] + data['1 1 1']
bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1']
bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']
self.log.info('test_telport: circuit:')
self.log.info(circuit.qasm())
self.log.info('test_teleport: data %s', data)
self.log.info('test_teleport: alice %s', alice)
self.log.info('test_teleport: bob %s', bob)
alice_ratio = 1 / np.tan(pi / 8)**2
bob_ratio = bob['0'] / float(bob['1'])
error = abs(alice_ratio - bob_ratio) / alice_ratio
self.log.info('test_teleport: relative error = %s', error)
self.assertLess(error, 0.05)
@unittest.skipIf(not do_profiling, "skipping simulator profiling.")
def profile_qasm_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
seed = 88
shots = 1024
n_circuits = 100
min_depth = 1
max_depth = 40
min_qubits = 1
max_qubits = 5
pr = cProfile.Profile()
random_circuits = RandomQasmGenerator(seed,
min_qubits=min_qubits,
max_qubits=max_qubits,
min_depth=min_depth,
max_depth=max_depth)
random_circuits.add_circuits(n_circuits)
self.qp = random_circuits.get_program()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend='local_qasm_simulator_py',
shots=shots)
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
self.log.info('------- start profiling QasmSimulatorPy -----------')
ps.print_stats()
self.log.info(sout.getvalue())
self.log.info('------- stop profiling QasmSimulatorPy -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
@unittest.skipIf(not do_profiling, "skipping simulator profiling.")
def profile_nqubit_speed_grow_depth(self):
"""simulation time vs the number of qubits
where the circuit depth is 10x the number of simulated
qubits. Also creates a pdf file with this module name showing a
plot of the results. Compilation is not included in speed.
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
qubit_range_max = 15
n_qubit_list = range(1, qubit_range_max + 1)
n_circuits = 10
shots = 1024
seed = 88
max_time = 30 # seconds; timing stops when simulation time exceeds this number
fmt_str1 = 'profile_nqubit_speed::nqubits:{0}, backend:{1}, elapsed_time:{2:.2f}'
fmt_str2 = 'backend:{0}, circuit:{1}, numOps:{2}, result:{3}'
fmt_str3 = 'minDepth={minDepth}, maxDepth={maxDepth}, num circuits={nCircuits},' \
'shots={shots}'
backend_list = [
'local_qasm_simulator_py', 'local_unitary_simulator_py'
]
if shutil.which('qasm_simulator'):
backend_list.append('local_qasm_simulator_cpp')
else:
self.log.info('profile_nqubit_speed::\"qasm_simulator\" executable'
'not in path...skipping')
fig = plt.figure(0)
plt.clf()
ax = fig.add_axes((0.1, 0.25, 0.8, 0.6))
for _, backend in enumerate(backend_list):
elapsed_time = np.zeros(len(n_qubit_list))
if backend == 'local_unitary_simulator_py':
do_measure = False
else:
do_measure = True
j, timed_out = 0, False
while j < qubit_range_max and not timed_out:
n_qubits = n_qubit_list[j]
random_circuits = RandomQasmGenerator(seed,
min_qubits=n_qubits,
max_qubits=n_qubits,
min_depth=n_qubits * 10,
max_depth=n_qubits * 10)
random_circuits.add_circuits(n_circuits, do_measure=do_measure)
qp = random_circuits.get_program()
c_names = qp.get_circuit_names()
qobj = qp.compile(c_names,
backend=backend,
shots=shots,
seed=seed)
start = time.perf_counter()
results = qp.run(qobj)
stop = time.perf_counter()
elapsed_time[j] = stop - start
if elapsed_time[j] > max_time:
timed_out = True
self.log.info(
fmt_str1.format(n_qubits, backend, elapsed_time[j]))
if backend != 'local_unitary_simulator_py':
for name in c_names:
log_str = fmt_str2.format(backend, name,
len(qp.get_circuit(name)),
results.get_data(name))
self.log.info(log_str)
j += 1
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
if backend == 'local_unitary_simulator_py':
ax.plot(n_qubit_list[:j],
elapsed_time[:j],
label=backend,
marker='o')
else:
ax.plot(n_qubit_list[:j],
elapsed_time[:j] / shots,
label=backend,
marker='o')
ax.set_yscale('log', basey=10)
ax.set_xlabel('number of qubits')
ax.set_ylabel('process time/shot')
ax.set_title('profile_nqubit_speed_grow_depth')
fig.text(
0.1, 0.05,
fmt_str3.format(minDepth='10*nQubits',
maxDepth='10*nQubits',
nCircuits=n_circuits,
shots=shots))
ax.legend()
self.pdf.savefig(fig)
@unittest.skipIf(not do_profiling, "skipping simulator profiling.")
def profile_nqubit_speed_constant_depth(self):
"""simulation time vs the number of qubits
where the circuit depth is fixed at 40. Also creates a pdf file
with this module name showing a plot of the results. Compilation
is not included in speed.
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
qubit_range_max = 15
n_qubit_list = range(1, qubit_range_max + 1)
max_depth = 40
min_depth = 40
n_circuits = 10
shots = 1024
seed = 88
max_time = 30 # seconds; timing stops when simulation time exceeds this number
fmt_str1 = 'profile_nqubit_speed::nqubits:{0}, backend:{1},' \
'elapsed_time:{2:.2f}'
fmt_str2 = 'backend:{0}, circuit:{1}, numOps:{2}, result:{3}'
fmt_str3 = 'minDepth={minDepth}, maxDepth={maxDepth},' \
'num circuits={nCircuits}, shots={shots}'
backend_list = [
'local_qasm_simulator_py', 'local_unitary_simulator_py'
]
if shutil.which('qasm_simulator'):
backend_list.append('local_qasm_simulator_cpp')
else:
self.log.info('profile_nqubit_speed::\"qasm_simulator\" executable'
'not in path...skipping')
fig = plt.figure(0)
plt.clf()
ax = fig.add_axes((0.1, 0.2, 0.8, 0.6))
for _, backend in enumerate(backend_list):
elapsedTime = np.zeros(len(n_qubit_list))
if backend == 'local_unitary_simulator_py':
doMeasure = False
else:
doMeasure = True
j, timedOut = 0, False
while j < qubit_range_max and not timedOut:
nQubits = n_qubit_list[j]
randomCircuits = RandomQasmGenerator(seed,
min_qubits=nQubits,
max_qubits=nQubits,
min_depth=min_depth,
max_depth=max_depth)
randomCircuits.add_circuits(n_circuits, do_measure=doMeasure)
qp = randomCircuits.get_program()
cnames = qp.get_circuit_names()
qobj = qp.compile(cnames,
backend=backend,
shots=shots,
seed=seed)
start = time.perf_counter()
results = qp.run(qobj)
stop = time.perf_counter()
elapsedTime[j] = stop - start
if elapsedTime[j] > max_time:
timedOut = True
self.log.info(fmt_str1.format(nQubits, backend,
elapsedTime[j]))
if backend != 'local_unitary_simulator_py':
for name in cnames:
log_str = fmt_str2.format(backend, name,
len(qp.get_circuit(name)),
results.get_data(name))
self.log.info(log_str)
j += 1
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
if backend == 'local_unitary_simulator_py':
ax.plot(n_qubit_list[:j],
elapsedTime[:j],
label=backend,
marker='o')
else:
ax.plot(n_qubit_list[:j],
elapsedTime[:j] / shots,
label=backend,
marker='o')
ax.set_yscale('log', basey=10)
ax.set_xlabel('number of qubits')
ax.set_ylabel('process time/shot')
ax.set_title('profile_nqubit_speed_constant_depth')
fig.text(
0.1, 0.05,
fmt_str3.format(minDepth=min_depth,
maxDepth=max_depth,
nCircuits=n_circuits,
shots=shots))
ax.legend()
self.pdf.savefig(fig)
class MapperTest(QiskitTestCase):
"""Test the mapper."""
def setUp(self):
self.seed = 42
self.qp = QuantumProgram()
def test_mapper_overoptimization(self):
"""
The mapper should not change the semantics of the input. An overoptimization introduced
the issue #81: https://github.com/QISKit/qiskit-sdk-py/issues/81
"""
self.qp.load_qasm_file(self._get_resource_path('qasm/overoptimization.qasm'), name='test')
coupling_map = {0: [2], 1: [2], 2: [3], 3: []}
result1 = self.qp.execute(["test"], backend="local_qasm_simulator",
coupling_map=coupling_map)
count1 = result1.get_counts("test")
result2 = self.qp.execute(["test"], backend="local_qasm_simulator", coupling_map=None)
count2 = result2.get_counts("test")
self.assertEqual(count1.keys(), count2.keys(), )
def test_math_domain_error(self):
"""
The math library operates over floats and introduce floating point errors that should be
avoided.
See: https://github.com/QISKit/qiskit-sdk-py/issues/111
"""
self.qp.load_qasm_file(self._get_resource_path('qasm/math_domain_error.qasm'), name='test')
coupling_map = {0: [2], 1: [2], 2: [3], 3: []}
result1 = self.qp.execute(["test"], backend="local_qasm_simulator",
coupling_map=coupling_map, seed=self.seed)
self.assertEqual(result1.get_counts("test"), {'0001': 507, '0101': 517})
def test_optimize_1q_gates_issue159(self):
"""Test change in behavior for optimize_1q_gates that removes u1(2*pi) rotations.
See: https://github.com/QISKit/qiskit-sdk-py/issues/159
"""
self.qp = QuantumProgram()
qr = self.qp.create_quantum_register('qr', 2)
cr = self.qp.create_classical_register('cr', 2)
qc = self.qp.create_circuit('Bell', [qr], [cr])
qc.h(qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
backend = 'local_qasm_simulator'
cmap = {1: [0], 2: [0, 1, 4], 3: [2, 4]}
qobj = self.qp.compile(["Bell"], backend=backend, coupling_map=cmap)
self.assertEqual(self.qp.get_compiled_qasm(qobj, "Bell"), EXPECTED_QASM_1Q_GATES_3_5)
def test_random_parameter_circuit(self):
"""Run a circuit with randomly generated parameters."""
self.qp.load_qasm_file(self._get_resource_path('qasm/random_n5_d5.qasm'), name='rand')
coupling_map = {0: [1], 1: [2], 2: [3], 3: [4]}
result1 = self.qp.execute(["rand"], backend="local_qasm_simulator",
coupling_map=coupling_map, seed=self.seed)
res = result1.get_counts("rand")
expected_result = {'10000': 97, '00011': 24, '01000': 120, '10111': 59, '01111': 37,
'11010': 14, '00001': 34, '00100': 42, '10110': 41, '00010': 102,
'00110': 48, '10101': 19, '01101': 61, '00111': 46, '11100': 28,
'01100': 1, '00000': 86, '11111': 14, '11011': 9, '10010': 35,
'10100': 20, '01001': 21, '01011': 19, '10011': 10, '11001': 13,
'00101': 4, '01010': 2, '01110': 17, '11000': 1}
self.assertEqual(res, expected_result)
def test_symbolic_unary(self):
"""Test symbolic math in DAGBackend and optimizer with a prefix.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_unary.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_UNARY)
def test_symbolic_binary(self):
"""Test symbolic math in DAGBackend and optimizer with a binary operation.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_binary.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_BINARY)
def test_symbolic_extern(self):
"""Test symbolic math in DAGBackend and optimizer with an external function.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_extern.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_EXTERN)
def test_symbolic_power(self):
"""Test symbolic math in DAGBackend and optimizer with a power (^).
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(data=QASM_SYMBOLIC_POWER).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_POWER)
class LocalUnitarySimulatorTest(QiskitTestCase):
"""Test local unitary simulator."""
def setUp(self):
self.seed = 88
self.qasmFileName = self._get_resource_path('qasm/example.qasm')
self.qp = QuantumProgram()
def tearDown(self):
pass
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
shots = 1024
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
#strip measurements from circuit to avoid warnings
circuit['operations'] = [
op for op in circuit['operations'] if op['name'] != 'measure'
]
# the simulator is expecting a JSON format, so we need to convert it back to JSON
qobj = {
'id':
'unitary',
'config': {
'max_credits': None,
'shots': 1,
'backend': 'local_unitary_simulator'
},
'circuits': [{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': self.qp.get_qasm('example'),
'config': {
'coupling_map': None,
'basis_gates': None,
'layout': None,
'seed': None
}
}]
}
# numpy.savetxt currently prints complex numbers in a way
# loadtxt can't read. To save file do,
# fmtstr=['% .4g%+.4gj' for i in range(numCols)]
# np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr, delimiter=',')
expected = np.loadtxt(
self._get_resource_path('example_unitary_matrix.dat'),
dtype='complex',
delimiter=',')
result = UnitarySimulator(qobj).run()
self.assertTrue(
np.allclose(result.get_data('test')['unitary'],
expected,
rtol=1e-3))
def profile_unitary_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
nCircuits = 100
maxDepth = 40
maxQubits = 5
pr = cProfile.Profile()
randomCircuits = RandomQasmGenerator(seed=self.seed,
maxDepth=maxDepth,
maxQubits=maxQubits)
randomCircuits.add_circuits(nCircuits, doMeasure=False)
self.qp = randomCircuits.getProgram()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend='local_unitary_simulator')
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
self.log.info('------- start profiling UnitarySimulator -----------')
ps.print_stats()
self.log.info(sout.getvalue())
self.log.info('------- stop profiling UnitarySimulator -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
class MapperTest(QiskitTestCase):
"""Test the mapper."""
def setUp(self):
self.seed = 42
self.qp = QuantumProgram()
def test_mapper_overoptimization(self):
"""
The mapper should not change the semantics of the input. An overoptimization introduced
the issue #81: https://github.com/QISKit/qiskit-sdk-py/issues/81
"""
self.qp.load_qasm_file(self._get_resource_path('qasm/overoptimization.qasm'), name='test')
coupling_map = [[0, 2], [1, 2], [2, 3]]
result1 = self.qp.execute(["test"], backend="local_qasm_simulator",
coupling_map=coupling_map)
count1 = result1.get_counts("test")
result2 = self.qp.execute(["test"], backend="local_qasm_simulator", coupling_map=None)
count2 = result2.get_counts("test")
self.assertEqual(count1.keys(), count2.keys(), )
def test_math_domain_error(self):
"""
The math library operates over floats and introduce floating point errors that should be
avoided.
See: https://github.com/QISKit/qiskit-sdk-py/issues/111
"""
self.qp.load_qasm_file(self._get_resource_path('qasm/math_domain_error.qasm'), name='test')
coupling_map = [[0, 2], [1, 2], [2, 3]]
shots = 2000
result = self.qp.execute("test", backend="local_qasm_simulator",
coupling_map=coupling_map,
seed=self.seed, shots=shots)
counts = result.get_counts("test")
target = {'0001': shots / 2, '0101': shots / 2}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts, target, threshold)
def test_optimize_1q_gates_issue159(self):
"""Test change in behavior for optimize_1q_gates that removes u1(2*pi) rotations.
See: https://github.com/QISKit/qiskit-sdk-py/issues/159
"""
self.qp = QuantumProgram()
qr = self.qp.create_quantum_register('qr', 2)
cr = self.qp.create_classical_register('cr', 2)
qc = self.qp.create_circuit('Bell', [qr], [cr])
qc.h(qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
backend = 'local_qasm_simulator'
coupling_map = [[1, 0], [2, 0], [2, 1], [2, 4], [3, 2], [3, 4]]
initial_layout = {('qr', 0): ('q', 1), ('qr', 1): ('q', 0)}
qobj = self.qp.compile(["Bell"], backend=backend,
initial_layout=initial_layout, coupling_map=coupling_map)
self.assertEqual(self.qp.get_compiled_qasm(qobj, "Bell"), EXPECTED_QASM_1Q_GATES_3_5)
def test_random_parameter_circuit(self):
"""Run a circuit with randomly generated parameters."""
self.qp.load_qasm_file(self._get_resource_path('qasm/random_n5_d5.qasm'), name='rand')
coupling_map = [[0, 1], [1, 2], [2, 3], [3, 4]]
shots = 1024
result1 = self.qp.execute(["rand"], backend="local_qasm_simulator",
coupling_map=coupling_map, shots=shots, seed=self.seed)
counts = result1.get_counts("rand")
expected_probs = {
'00000': 0.079239867254200971,
'00001': 0.032859032998526903,
'00010': 0.10752610993531816,
'00011': 0.018818532050952699,
'00100': 0.054830807251011054,
'00101': 0.0034141983951965164,
'00110': 0.041649309748902276,
'00111': 0.039967731207338125,
'01000': 0.10516937819949743,
'01001': 0.026635620063700002,
'01010': 0.0053475143548793866,
'01011': 0.01940513314416064,
'01100': 0.0044028405481225047,
'01101': 0.057524760052126644,
'01110': 0.010795354134597078,
'01111': 0.026491296821535528,
'10000': 0.094827455395274859,
'10001': 0.0008373965072688836,
'10010': 0.029082297894094441,
'10011': 0.012386622870598416,
'10100': 0.018739140061148799,
'10101': 0.01367656456536896,
'10110': 0.039184170706009248,
'10111': 0.062339335178438288,
'11000': 0.00293674365989009,
'11001': 0.012848433960739968,
'11010': 0.018472497159499782,
'11011': 0.0088903691234912003,
'11100': 0.031305389080034329,
'11101': 0.0004788556283690458,
'11110': 0.002232419390471667,
'11111': 0.017684822659235985
}
target = {key: shots * val for key, val in expected_probs.items()}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts, target, threshold)
def test_symbolic_unary(self):
"""Test symbolic math in DAGBackend and optimizer with a prefix.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_unary.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_UNARY)
def test_symbolic_binary(self):
"""Test symbolic math in DAGBackend and optimizer with a binary operation.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_binary.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_BINARY)
def test_symbolic_extern(self):
"""Test symbolic math in DAGBackend and optimizer with an external function.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_extern.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_EXTERN)
def test_symbolic_power(self):
"""Test symbolic math in DAGBackend and optimizer with a power (^).
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(data=QASM_SYMBOLIC_POWER).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_POWER)
def test_already_mapped(self):
"""Test that if the circuit already matches the backend topology, it is not remapped.
See: https://github.com/QISKit/qiskit-sdk-py/issues/342
"""
self.qp = QuantumProgram()
qr = self.qp.create_quantum_register('qr', 16)
cr = self.qp.create_classical_register('cr', 16)
qc = self.qp.create_circuit('native_cx', [qr], [cr])
qc.cx(qr[3], qr[14])
qc.cx(qr[5], qr[4])
qc.h(qr[9])
qc.cx(qr[9], qr[8])
qc.x(qr[11])
qc.cx(qr[3], qr[4])
qc.cx(qr[12], qr[11])
qc.cx(qr[13], qr[4])
for j in range(16):
qc.measure(qr[j], cr[j])
backend = 'local_qasm_simulator'
coupling_map = [[1, 0], [1, 2], [2, 3], [3, 4], [3, 14], [5, 4],
[6, 5], [6, 7], [6, 11], [7, 10], [8, 7], [9, 8],
[9, 10], [11, 10], [12, 5], [12, 11], [12, 13],
[13, 4], [13, 14], [15, 0], [15, 2], [15, 14]]
qobj = self.qp.compile(["native_cx"], backend=backend, coupling_map=coupling_map)
cx_qubits = [x["qubits"]
for x in qobj["circuits"][0]["compiled_circuit"]["operations"]
if x["name"] == "cx"]
self.assertEqual(sorted(cx_qubits), [[3, 4], [3, 14], [5, 4], [9, 8], [12, 11], [13, 4]])
class LocalUnitarySimulatorTest(unittest.TestCase):
"""Test local unitary simulator."""
def setUp(self):
self.seed = 88
self.qasmFileName = os.path.join(qiskit.__path__[0],
'../test/python/qasm/example.qasm')
self.qp = QuantumProgram()
self.moduleName = os.path.splitext(__file__)[0]
self.modulePath = os.path.dirname(__file__)
logFileName = self.moduleName + '.log'
logging.basicConfig(filename=logFileName, level=logging.INFO)
def tearDown(self):
pass
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
shots = 1024
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
# if we want to manipulate the circuit, we have to convert it to a dict
circuit = json.loads(circuit.decode())
#strip measurements from circuit to avoid warnings
circuit['operations'] = [op for op in circuit['operations']
if op['name'] != 'measure']
# the simulator is expecting a JSON format, so we need to convert it back to JSON
job = {'compiled_circuit': json.dumps(circuit).encode()}
# numpy savetxt is currently prints complex numbers in a way
# loadtxt can't read. To save file do,
# fmtstr=['% .4g%+.4gj' for i in range(numCols)]
# np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr, delimiter=',')
expected = np.loadtxt(os.path.join(self.modulePath,
'example_unitary_matrix.dat'),
dtype='complex', delimiter=',')
result = UnitarySimulator(job).run()
self.assertTrue(np.allclose(result['data']['unitary'], expected,
rtol=1e-3))
def profile_unitary_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
nCircuits = 100
maxDepth = 40
maxQubits = 5
pr = cProfile.Profile()
randomCircuits = RandomQasmGenerator(seed=self.seed,
maxDepth=maxDepth,
maxQubits=maxQubits)
randomCircuits.add_circuits(nCircuits, doMeasure=False)
self.qp = randomCircuits.getProgram()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend='local_unitary_simulator')
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
logging.info('------- start profiling UnitarySimulator -----------')
ps.print_stats()
logging.info(sout.getvalue())
logging.info('------- stop profiling UnitarySimulator -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
class LocalSimulatorTest(unittest.TestCase):
"""
Test interface to local simulators.
"""
@classmethod
def setUpClass(cls):
cls.moduleName = os.path.splitext(__file__)[0]
cls.log = logging.getLogger(__name__)
cls.log.setLevel(logging.INFO)
logFileName = cls.moduleName + '.log'
handler = logging.FileHandler(logFileName)
handler.setLevel(logging.INFO)
log_fmt = ('{}.%(funcName)s:%(levelname)s:%(asctime)s:'
' %(message)s'.format(cls.__name__))
formatter = logging.Formatter(log_fmt)
handler.setFormatter(formatter)
cls.log.addHandler(handler)
@classmethod
def tearDownClass(cls):
#cls.pdf.close()
pass
def setUp(self):
self.seed = 88
self.qasmFileName = os.path.join(qiskit.__path__[0],
'../test/python/qasm/example.qasm')
self.qp = QuantumProgram()
shots = 1
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
self.job = {'compiled_circuit': circuit,
'config': {'shots': shots, 'seed': random.randint(0, 10)}
}
def tearDown(self):
pass
def test_local_configuration_present(self):
self.assertTrue(_localsimulator.local_configuration)
def test_local_configurations(self):
required_keys = ['name',
'url',
'simulator',
'description',
'coupling_map',
'basis_gates']
for conf in _localsimulator.local_configuration:
for key in required_keys:
self.assertIn(key, conf.keys())
def test_simulator_classes(self):
cdict = _localsimulator._simulator_classes
cdict = getattr(_localsimulator, '_simulator_classes')
self.log.info('found local simulators: {0}'.format(repr(cdict)))
self.assertTrue(cdict)
def test_local_backends(self):
backends = _localsimulator.local_backends()
self.log.info('found local backends: {0}'.format(repr(backends)))
self.assertTrue(backends)
def test_instantiation(self):
"""
Test instantiation of LocalSimulator
"""
backend_list = _localsimulator.local_backends()
for backend_name in backend_list:
backend = _localsimulator.LocalSimulator(backend_name, self.job)
class LocalSimulatorTest(QiskitTestCase):
"""
Test interface to local simulators.
"""
def setUp(self):
self.seed = 88
self.qasmFileName = self._get_resource_path('qasm/example.qasm')
self.qp = QuantumProgram()
shots = 1
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
self.qobj = {
'id':
'test_qobj',
'config': {
'max_credits': 3,
'shots': 100,
'backend': 'local_qasm_simulator',
},
'circuits': [{
'name': 'test_circuit',
'compiled_circuit': circuit,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': None
}]
}
def tearDown(self):
pass
def test_local_configuration_present(self):
self.assertTrue(_localsimulator.local_configuration)
def test_local_configurations(self):
required_keys = [
'name', 'url', 'simulator', 'description', 'coupling_map',
'basis_gates'
]
for conf in _localsimulator.local_configuration:
for key in required_keys:
self.assertIn(key, conf.keys())
def test_simulator_classes(self):
cdict = _localsimulator._simulator_classes
cdict = getattr(_localsimulator, '_simulator_classes')
self.log.info('found local simulators: {0}'.format(repr(cdict)))
self.assertTrue(cdict)
def test_local_backends(self):
backends = _localsimulator.local_backends()
self.log.info('found local backends: {0}'.format(repr(backends)))
self.assertTrue(backends)
def test_instantiation(self):
"""
Test instantiation of LocalSimulator
"""
backend_list = _localsimulator.local_backends()
for backend_name in backend_list:
backend = _localsimulator.LocalSimulator(self.qobj)
class MapperTest(QiskitTestCase):
"""Test the mapper."""
def setUp(self):
self.seed = 42
self.qp = QuantumProgram()
def test_mapper_overoptimization(self):
"""
The mapper should not change the semantics of the input. An overoptimization introduced
the issue #81: https://github.com/QISKit/qiskit-terra/issues/81
"""
self.qp.load_qasm_file(
self._get_resource_path('qasm/overoptimization.qasm'), name='test')
coupling_map = [[0, 2], [1, 2], [2, 3]]
result1 = self.qp.execute(["test"],
backend="local_qasm_simulator",
coupling_map=coupling_map)
count1 = result1.get_counts("test")
result2 = self.qp.execute(["test"],
backend="local_qasm_simulator",
coupling_map=None)
count2 = result2.get_counts("test")
self.assertEqual(
count1.keys(),
count2.keys(),
)
def test_math_domain_error(self):
"""
The math library operates over floats and introduce floating point errors that should be
avoided.
See: https://github.com/QISKit/qiskit-terra/issues/111
"""
self.qp.load_qasm_file(
self._get_resource_path('qasm/math_domain_error.qasm'),
name='test')
coupling_map = [[0, 2], [1, 2], [2, 3]]
shots = 2000
result = self.qp.execute("test",
backend="local_qasm_simulator",
coupling_map=coupling_map,
seed=self.seed,
shots=shots)
counts = result.get_counts("test")
target = {'0001': shots / 2, '0101': shots / 2}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts, target, threshold)
def test_optimize_1q_gates_issue159(self):
"""Test change in behavior for optimize_1q_gates that removes u1(2*pi) rotations.
See: https://github.com/QISKit/qiskit-terra/issues/159
"""
self.qp = QuantumProgram()
qr = self.qp.create_quantum_register('qr', 2)
cr = self.qp.create_classical_register('cr', 2)
qc = self.qp.create_circuit('Bell', [qr], [cr])
qc.h(qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
backend = 'local_qasm_simulator'
coupling_map = [[1, 0], [2, 0], [2, 1], [2, 4], [3, 2], [3, 4]]
initial_layout = {('qr', 0): ('q', 1), ('qr', 1): ('q', 0)}
qobj = self.qp.compile(["Bell"],
backend=backend,
initial_layout=initial_layout,
coupling_map=coupling_map)
self.assertEqual(self.qp.get_compiled_qasm(qobj, "Bell"),
EXPECTED_QASM_1Q_GATES_3_5)
def test_random_parameter_circuit(self):
"""Run a circuit with randomly generated parameters."""
self.qp.load_qasm_file(
self._get_resource_path('qasm/random_n5_d5.qasm'), name='rand')
coupling_map = [[0, 1], [1, 2], [2, 3], [3, 4]]
shots = 1024
result1 = self.qp.execute(["rand"],
backend="local_qasm_simulator",
coupling_map=coupling_map,
shots=shots,
seed=self.seed)
counts = result1.get_counts("rand")
expected_probs = {
'00000': 0.079239867254200971,
'00001': 0.032859032998526903,
'00010': 0.10752610993531816,
'00011': 0.018818532050952699,
'00100': 0.054830807251011054,
'00101': 0.0034141983951965164,
'00110': 0.041649309748902276,
'00111': 0.039967731207338125,
'01000': 0.10516937819949743,
'01001': 0.026635620063700002,
'01010': 0.0053475143548793866,
'01011': 0.01940513314416064,
'01100': 0.0044028405481225047,
'01101': 0.057524760052126644,
'01110': 0.010795354134597078,
'01111': 0.026491296821535528,
'10000': 0.094827455395274859,
'10001': 0.0008373965072688836,
'10010': 0.029082297894094441,
'10011': 0.012386622870598416,
'10100': 0.018739140061148799,
'10101': 0.01367656456536896,
'10110': 0.039184170706009248,
'10111': 0.062339335178438288,
'11000': 0.00293674365989009,
'11001': 0.012848433960739968,
'11010': 0.018472497159499782,
'11011': 0.0088903691234912003,
'11100': 0.031305389080034329,
'11101': 0.0004788556283690458,
'11110': 0.002232419390471667,
'11111': 0.017684822659235985
}
target = {key: shots * val for key, val in expected_probs.items()}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts, target, threshold)
def test_symbolic_unary(self):
"""Test symbolic math in DAGBackend and optimizer with a prefix.
See: https://github.com/QISKit/qiskit-terra/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_unary.qasm')).parse()
unr = unroll.Unroller(ast,
backend=unroll.DAGBackend(
["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_UNARY)
def test_symbolic_binary(self):
"""Test symbolic math in DAGBackend and optimizer with a binary operation.
See: https://github.com/QISKit/qiskit-terra/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_binary.qasm')).parse()
unr = unroll.Unroller(ast,
backend=unroll.DAGBackend(
["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_BINARY)
def test_symbolic_extern(self):
"""Test symbolic math in DAGBackend and optimizer with an external function.
See: https://github.com/QISKit/qiskit-terra/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_extern.qasm')).parse()
unr = unroll.Unroller(ast,
backend=unroll.DAGBackend(
["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_EXTERN)
def test_symbolic_power(self):
"""Test symbolic math in DAGBackend and optimizer with a power (^).
See: https://github.com/QISKit/qiskit-terra/issues/172
"""
ast = qasm.Qasm(data=QASM_SYMBOLIC_POWER).parse()
unr = unroll.Unroller(ast,
backend=unroll.DAGBackend(
["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_POWER)
def test_already_mapped(self):
"""Test that if the circuit already matches the backend topology, it is not remapped.
See: https://github.com/QISKit/qiskit-terra/issues/342
"""
self.qp = QuantumProgram()
qr = self.qp.create_quantum_register('qr', 16)
cr = self.qp.create_classical_register('cr', 16)
qc = self.qp.create_circuit('native_cx', [qr], [cr])
qc.cx(qr[3], qr[14])
qc.cx(qr[5], qr[4])
qc.h(qr[9])
qc.cx(qr[9], qr[8])
qc.x(qr[11])
qc.cx(qr[3], qr[4])
qc.cx(qr[12], qr[11])
qc.cx(qr[13], qr[4])
for j in range(16):
qc.measure(qr[j], cr[j])
backend = 'local_qasm_simulator'
coupling_map = [[1, 0], [1, 2], [2, 3], [3, 4],
[3, 14], [5, 4], [6, 5], [6, 7], [6, 11], [7, 10],
[8, 7], [9, 8], [9, 10], [11, 10], [12, 5], [12, 11],
[12, 13], [13, 4], [13, 14], [15, 0], [15,
2], [15, 14]]
qobj = self.qp.compile(["native_cx"],
backend=backend,
coupling_map=coupling_map)
cx_qubits = [
x.qubits for x in qobj.experiments[0].instructions
if x.name == "cx"
]
self.assertEqual(sorted(cx_qubits),
[[3, 4], [3, 14], [5, 4], [9, 8], [12, 11], [13, 4]])
def test_yzy_zyz_cases(self):
"""Test mapper function yzy_to_zyz works in previously failed cases.
See: https://github.com/QISKit/qiskit-terra/issues/607
"""
backend = FakeQX4BackEnd()
circ1 = load_qasm_string(yzy_zyz_1)
qobj1 = qiskit.wrapper.compile(circ1, backend)
self.assertIsInstance(qobj1, Qobj)
circ2 = load_qasm_string(yzy_zyz_2)
qobj2 = qiskit.wrapper.compile(circ2, backend)
self.assertIsInstance(qobj2, Qobj)
class UnitarySimulatorSympyTest(QiskitTestCase):
"""Test local unitary simulator sympy."""
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/simple.qasm')
self.qp = QuantumProgram()
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
# strip measurements from circuit to avoid warnings
circuit['operations'] = [op for op in circuit['operations']
if op['name'] != 'measure']
# the simulator is expecting a JSON format, so we need to convert it
# back to JSON
qobj = {
'id': 'unitary',
'config': {
'max_credits': None,
'shots': 1,
'backend_name': 'local_sympy_unitary_simulator'
},
'circuits': [
{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': self.qp.get_qasm('example'),
'config': {
'coupling_map': None,
'basis_gates': None,
'layout': None,
'seed': None
}
}
]
}
q_job = QuantumJob(qobj,
backend=UnitarySimulatorSympy(),
preformatted=True)
result = UnitarySimulatorSympy().run(q_job).result()
actual = result.get_data('test')['unitary']
self.assertEqual(actual[0][0], sqrt(2)/2)
self.assertEqual(actual[0][1], sqrt(2)/2)
self.assertEqual(actual[0][2], 0)
self.assertEqual(actual[0][3], 0)
self.assertEqual(actual[1][0], 0)
self.assertEqual(actual[1][1], 0)
self.assertEqual(actual[1][2], sqrt(2)/2)
self.assertEqual(actual[1][3], -sqrt(2)/2)
self.assertEqual(actual[2][0], 0)
self.assertEqual(actual[2][1], 0)
self.assertEqual(actual[2][2], sqrt(2)/2)
self.assertEqual(actual[2][3], sqrt(2)/2)
self.assertEqual(actual[3][0], sqrt(2)/2)
self.assertEqual(actual[3][1], -sqrt(2)/2)
self.assertEqual(actual[3][2], 0)
self.assertEqual(actual[3][3], 0)
class TestLocalQasmSimulatorPy(QiskitTestCase):
"""Test local_qasm_simulator_py."""
@classmethod
def setUpClass(cls):
super().setUpClass()
if do_profiling:
cls.pdf = PdfPages(cls.moduleName + '.pdf')
@classmethod
def tearDownClass(cls):
if do_profiling:
cls.pdf.close()
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/example.qasm')
self.qp = QuantumProgram()
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
circuit_config = {'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': self.seed}
resources = {'max_credits': 3}
self.qobj = {'id': 'test_sim_single_shot',
'config': {
'max_credits': resources['max_credits'],
'shots': 1024,
'backend_name': 'local_qasm_simulator_py',
},
'circuits': [
{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': None,
'config': circuit_config
}
]}
self.q_job = QuantumJob(self.qobj,
backend=QasmSimulatorPy(),
circuit_config=circuit_config,
seed=self.seed,
resources=resources,
preformatted=True)
def tearDown(self):
pass
def test_qasm_simulator_single_shot(self):
"""Test single shot run."""
shots = 1
self.qobj['config']['shots'] = shots
result = QasmSimulatorPy().run(self.q_job).result()
self.assertEqual(result.get_status(), 'COMPLETED')
def test_qasm_simulator(self):
"""Test data counts output for single circuit run against reference."""
result = QasmSimulatorPy().run(self.q_job).result()
shots = 1024
threshold = 0.04 * shots
counts = result.get_counts('test')
target = {'100 100': shots / 8, '011 011': shots / 8,
'101 101': shots / 8, '111 111': shots / 8,
'000 000': shots / 8, '010 010': shots / 8,
'110 110': shots / 8, '001 001': shots / 8}
self.assertDictAlmostEqual(counts, target, threshold)
def test_if_statement(self):
self.log.info('test_if_statement_x')
shots = 100
max_qubits = 3
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', max_qubits)
cr = qp.create_classical_register('cr', max_qubits)
circuit_if_true = qp.create_circuit('test_if_true', [qr], [cr])
circuit_if_true.x(qr[0])
circuit_if_true.x(qr[1])
circuit_if_true.measure(qr[0], cr[0])
circuit_if_true.measure(qr[1], cr[1])
circuit_if_true.x(qr[2]).c_if(cr, 0x3)
circuit_if_true.measure(qr[0], cr[0])
circuit_if_true.measure(qr[1], cr[1])
circuit_if_true.measure(qr[2], cr[2])
circuit_if_false = qp.create_circuit('test_if_false', [qr], [cr])
circuit_if_false.x(qr[0])
circuit_if_false.measure(qr[0], cr[0])
circuit_if_false.measure(qr[1], cr[1])
circuit_if_false.x(qr[2]).c_if(cr, 0x3)
circuit_if_false.measure(qr[0], cr[0])
circuit_if_false.measure(qr[1], cr[1])
circuit_if_false.measure(qr[2], cr[2])
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_true')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit_true = unroller.execute()
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_false')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit_false = unroller.execute()
qobj = {
'id': 'test_if_qobj',
'config': {
'max_credits': 3,
'shots': shots,
'backend_name': 'local_qasm_simulator_py',
},
'circuits': [
{
'name': 'test_if_true',
'compiled_circuit': ucircuit_true,
'compiled_circuit_qasm': None,
'config': {
'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': None
}
},
{
'name': 'test_if_false',
'compiled_circuit': ucircuit_false,
'compiled_circuit_qasm': None,
'config': {
'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': None
}
}
]
}
q_job = QuantumJob(qobj, backend=QasmSimulatorPy(), preformatted=True)
result = QasmSimulatorPy().run(q_job).result()
result_if_true = result.get_data('test_if_true')
self.log.info('result_if_true circuit:')
self.log.info(circuit_if_true.qasm())
self.log.info('result_if_true=%s', result_if_true)
result_if_false = result.get_data('test_if_false')
self.log.info('result_if_false circuit:')
self.log.info(circuit_if_false.qasm())
self.log.info('result_if_false=%s', result_if_false)
self.assertTrue(result_if_true['counts']['111'] == 100)
self.assertTrue(result_if_false['counts']['001'] == 100)
@unittest.skipIf(version_info.minor == 5, "Due to gate ordering issues with Python 3.5 \
we have to disable this test until fixed")
def test_teleport(self):
"""test teleportation as in tutorials"""
self.log.info('test_teleport')
pi = np.pi
shots = 1000
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 3)
cr0 = qp.create_classical_register('cr0', 1)
cr1 = qp.create_classical_register('cr1', 1)
cr2 = qp.create_classical_register('cr2', 1)
circuit = qp.create_circuit('teleport', [qr],
[cr0, cr1, cr2])
circuit.h(qr[1])
circuit.cx(qr[1], qr[2])
circuit.ry(pi/4, qr[0])
circuit.cx(qr[0], qr[1])
circuit.h(qr[0])
circuit.barrier(qr)
circuit.measure(qr[0], cr0[0])
circuit.measure(qr[1], cr1[0])
circuit.z(qr[2]).c_if(cr0, 1)
circuit.x(qr[2]).c_if(cr1, 1)
circuit.measure(qr[2], cr2[0])
backend = 'local_qasm_simulator_py'
qobj = qp.compile('teleport', backend=backend, shots=shots,
seed=self.seed)
results = qp.run(qobj)
data = results.get_counts('teleport')
alice = {}
bob = {}
alice['00'] = data['0 0 0'] + data['1 0 0']
alice['01'] = data['0 1 0'] + data['1 1 0']
alice['10'] = data['0 0 1'] + data['1 0 1']
alice['11'] = data['0 1 1'] + data['1 1 1']
bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1']
bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']
self.log.info('test_telport: circuit:')
self.log.info(circuit.qasm())
self.log.info('test_teleport: data %s', data)
self.log.info('test_teleport: alice %s', alice)
self.log.info('test_teleport: bob %s', bob)
alice_ratio = 1/np.tan(pi/8)**2
bob_ratio = bob['0']/float(bob['1'])
error = abs(alice_ratio - bob_ratio) / alice_ratio
self.log.info('test_teleport: relative error = %s', error)
self.assertLess(error, 0.05)
@unittest.skipIf(not do_profiling, "skipping simulator profiling.")
def profile_qasm_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
seed = 88
shots = 1024
n_circuits = 100
min_depth = 1
max_depth = 40
min_qubits = 1
max_qubits = 5
pr = cProfile.Profile()
random_circuits = RandomQasmGenerator(seed,
min_qubits=min_qubits,
max_qubits=max_qubits,
min_depth=min_depth,
max_depth=max_depth)
random_circuits.add_circuits(n_circuits)
self.qp = random_circuits.get_program()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend='local_qasm_simulator_py',
shots=shots)
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
self.log.info('------- start profiling QasmSimulatorPy -----------')
ps.print_stats()
self.log.info(sout.getvalue())
self.log.info('------- stop profiling QasmSimulatorPy -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
@unittest.skipIf(not do_profiling, "skipping simulator profiling.")
def profile_nqubit_speed_grow_depth(self):
"""simulation time vs the number of qubits
where the circuit depth is 10x the number of simulated
qubits. Also creates a pdf file with this module name showing a
plot of the results. Compilation is not included in speed.
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
qubit_range_max = 15
n_qubit_list = range(1, qubit_range_max + 1)
n_circuits = 10
shots = 1024
seed = 88
max_time = 30 # seconds; timing stops when simulation time exceeds this number
fmt_str1 = 'profile_nqubit_speed::nqubits:{0}, backend:{1}, elapsed_time:{2:.2f}'
fmt_str2 = 'backend:{0}, circuit:{1}, numOps:{2}, result:{3}'
fmt_str3 = 'minDepth={minDepth}, maxDepth={maxDepth}, num circuits={nCircuits},' \
'shots={shots}'
backend_list = ['local_qasm_simulator_py', 'local_unitary_simulator_py']
if shutil.which('qasm_simulator'):
backend_list.append('local_qasm_simulator_cpp')
else:
self.log.info('profile_nqubit_speed::\"qasm_simulator\" executable'
'not in path...skipping')
fig = plt.figure(0)
plt.clf()
ax = fig.add_axes((0.1, 0.25, 0.8, 0.6))
for _, backend in enumerate(backend_list):
elapsed_time = np.zeros(len(n_qubit_list))
if backend == 'local_unitary_simulator_py':
do_measure = False
else:
do_measure = True
j, timed_out = 0, False
while j < qubit_range_max and not timed_out:
n_qubits = n_qubit_list[j]
random_circuits = RandomQasmGenerator(seed,
min_qubits=n_qubits,
max_qubits=n_qubits,
min_depth=n_qubits * 10,
max_depth=n_qubits * 10)
random_circuits.add_circuits(n_circuits, do_measure=do_measure)
qp = random_circuits.get_program()
c_names = qp.get_circuit_names()
qobj = qp.compile(c_names, backend=backend, shots=shots,
seed=seed)
start = time.perf_counter()
results = qp.run(qobj)
stop = time.perf_counter()
elapsed_time[j] = stop - start
if elapsed_time[j] > max_time:
timed_out = True
self.log.info(fmt_str1.format(n_qubits, backend, elapsed_time[j]))
if backend != 'local_unitary_simulator_py':
for name in c_names:
log_str = fmt_str2.format(
backend, name, len(qp.get_circuit(name)),
results.get_data(name))
self.log.info(log_str)
j += 1
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
if backend == 'local_unitary_simulator_py':
ax.plot(n_qubit_list[:j], elapsed_time[:j], label=backend, marker='o')
else:
ax.plot(n_qubit_list[:j], elapsed_time[:j]/shots, label=backend,
marker='o')
ax.set_yscale('log', basey=10)
ax.set_xlabel('number of qubits')
ax.set_ylabel('process time/shot')
ax.set_title('profile_nqubit_speed_grow_depth')
fig.text(0.1, 0.05,
fmt_str3.format(minDepth='10*nQubits', maxDepth='10*nQubits',
nCircuits=n_circuits, shots=shots))
ax.legend()
self.pdf.savefig(fig)
@unittest.skipIf(not do_profiling, "skipping simulator profiling.")
def profile_nqubit_speed_constant_depth(self):
"""simulation time vs the number of qubits
where the circuit depth is fixed at 40. Also creates a pdf file
with this module name showing a plot of the results. Compilation
is not included in speed.
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
qubit_range_max = 15
n_qubit_list = range(1, qubit_range_max + 1)
max_depth = 40
min_depth = 40
n_circuits = 10
shots = 1024
seed = 88
max_time = 30 # seconds; timing stops when simulation time exceeds this number
fmt_str1 = 'profile_nqubit_speed::nqubits:{0}, backend:{1},' \
'elapsed_time:{2:.2f}'
fmt_str2 = 'backend:{0}, circuit:{1}, numOps:{2}, result:{3}'
fmt_str3 = 'minDepth={minDepth}, maxDepth={maxDepth},' \
'num circuits={nCircuits}, shots={shots}'
backend_list = ['local_qasm_simulator_py', 'local_unitary_simulator_py']
if shutil.which('qasm_simulator'):
backend_list.append('local_qasm_simulator_cpp')
else:
self.log.info('profile_nqubit_speed::\"qasm_simulator\" executable'
'not in path...skipping')
fig = plt.figure(0)
plt.clf()
ax = fig.add_axes((0.1, 0.2, 0.8, 0.6))
for _, backend in enumerate(backend_list):
elapsedTime = np.zeros(len(n_qubit_list))
if backend == 'local_unitary_simulator_py':
doMeasure = False
else:
doMeasure = True
j, timedOut = 0, False
while j < qubit_range_max and not timedOut:
nQubits = n_qubit_list[j]
randomCircuits = RandomQasmGenerator(seed,
min_qubits=nQubits,
max_qubits=nQubits,
min_depth=min_depth,
max_depth=max_depth)
randomCircuits.add_circuits(n_circuits, do_measure=doMeasure)
qp = randomCircuits.get_program()
cnames = qp.get_circuit_names()
qobj = qp.compile(cnames, backend=backend, shots=shots, seed=seed)
start = time.perf_counter()
results = qp.run(qobj)
stop = time.perf_counter()
elapsedTime[j] = stop - start
if elapsedTime[j] > max_time:
timedOut = True
self.log.info(fmt_str1.format(nQubits, backend, elapsedTime[j]))
if backend != 'local_unitary_simulator_py':
for name in cnames:
log_str = fmt_str2.format(
backend, name, len(qp.get_circuit(name)),
results.get_data(name))
self.log.info(log_str)
j += 1
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
if backend == 'local_unitary_simulator_py':
ax.plot(n_qubit_list[:j], elapsedTime[:j], label=backend, marker='o')
else:
ax.plot(n_qubit_list[:j], elapsedTime[:j]/shots, label=backend,
marker='o')
ax.set_yscale('log', basey=10)
ax.set_xlabel('number of qubits')
ax.set_ylabel('process time/shot')
ax.set_title('profile_nqubit_speed_constant_depth')
fig.text(0.1, 0.05,
fmt_str3.format(minDepth=min_depth, maxDepth=max_depth,
nCircuits=n_circuits, shots=shots))
ax.legend()
self.pdf.savefig(fig)
class MapperTest(QiskitTestCase):
"""Test the mapper."""
def setUp(self):
self.seed = 42
self.qp = QuantumProgram()
def test_mapper_overoptimization(self):
"""
The mapper should not change the semantics of the input. An overoptimization introduced
the issue #81: https://github.com/QISKit/qiskit-sdk-py/issues/81
"""
self.qp.load_qasm_file(self._get_resource_path('qasm/overoptimization.qasm'), name='test')
coupling_map = [[0, 2], [1, 2], [2, 3]]
result1 = self.qp.execute(["test"], backend="local_qasm_simulator",
coupling_map=coupling_map)
count1 = result1.get_counts("test")
result2 = self.qp.execute(["test"], backend="local_qasm_simulator", coupling_map=None)
count2 = result2.get_counts("test")
self.assertEqual(count1.keys(), count2.keys(), )
def test_math_domain_error(self):
"""
The math library operates over floats and introduce floating point errors that should be
avoided.
See: https://github.com/QISKit/qiskit-sdk-py/issues/111
"""
self.qp.load_qasm_file(self._get_resource_path('qasm/math_domain_error.qasm'), name='test')
coupling_map = [[0, 2], [1, 2], [2, 3]]
result1 = self.qp.execute(["test"], backend="local_qasm_simulator",
coupling_map=coupling_map, seed=self.seed)
self.assertEqual(result1.get_counts("test"), {'0001': 480, '0101': 544})
def test_optimize_1q_gates_issue159(self):
"""Test change in behavior for optimize_1q_gates that removes u1(2*pi) rotations.
See: https://github.com/QISKit/qiskit-sdk-py/issues/159
"""
self.qp = QuantumProgram()
qr = self.qp.create_quantum_register('qr', 2)
cr = self.qp.create_classical_register('cr', 2)
qc = self.qp.create_circuit('Bell', [qr], [cr])
qc.h(qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
backend = 'local_qasm_simulator'
coupling_map = [[1, 0], [2, 0], [2, 1], [2, 4], [3, 2], [3, 4]]
initial_layout = {('qr', 0): ('q', 1), ('qr', 1): ('q', 0)}
qobj = self.qp.compile(["Bell"], backend=backend,
initial_layout=initial_layout, coupling_map=coupling_map)
self.assertEqual(self.qp.get_compiled_qasm(qobj, "Bell"), EXPECTED_QASM_1Q_GATES_3_5)
def test_random_parameter_circuit(self):
"""Run a circuit with randomly generated parameters."""
self.qp.load_qasm_file(self._get_resource_path('qasm/random_n5_d5.qasm'), name='rand')
coupling_map = [[0, 1], [1, 2], [2, 3], [3, 4]]
result1 = self.qp.execute(["rand"], backend="local_qasm_simulator",
coupling_map=coupling_map, seed=self.seed)
res = result1.get_counts("rand")
print(res)
expected_result = {'10000': 92, '10100': 27, '01000': 99, '00001': 37,
'11100': 31, '01001': 27, '10111': 79, '00111': 43,
'00000': 88, '00010': 104, '11111': 14, '00110': 52,
'00100': 50, '01111': 21, '10010': 34, '01011': 21,
'00011': 15, '01101': 53, '10110': 32, '10101': 12,
'01100': 8, '01010': 7, '10011': 15, '11010': 26,
'11011': 8, '11110': 4, '01110': 14, '11001': 6,
'11000': 1, '11101': 2, '00101': 2}
# TODO It's ugly, I know. But we are getting different results from Python 3.5
# and Python 3.6. So let's trick this until we fix all testing
if expected_result != res:
expected_result = {'00001': 31, '01111': 23, '10010': 24, '01001': 29,
'11000': 4, '10111': 74, '00101': 3, '11010': 21,
'01100': 11, '11110': 2, '11101': 2, '11001': 18,
'01011': 17, '00100': 45, '01010': 1, '11111': 13,
'00011': 20, '00110': 35, '00000': 87, '10101': 12,
'01110': 11, '00010': 122, '10100': 21, '10000': 88,
'10110': 34, '01000': 108, '11011': 8, '10011': 14,
'01101': 58, '00111': 48, '11100': 40}
self.assertEqual(res, expected_result)
def test_symbolic_unary(self):
"""Test symbolic math in DAGBackend and optimizer with a prefix.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_unary.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_UNARY)
def test_symbolic_binary(self):
"""Test symbolic math in DAGBackend and optimizer with a binary operation.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_binary.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_BINARY)
def test_symbolic_extern(self):
"""Test symbolic math in DAGBackend and optimizer with an external function.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_extern.qasm')).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_EXTERN)
def test_symbolic_power(self):
"""Test symbolic math in DAGBackend and optimizer with a power (^).
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(data=QASM_SYMBOLIC_POWER).parse()
unr = unroll.Unroller(ast, backend=unroll.DAGBackend(["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_POWER)
def test_already_mapped(self):
"""Test that if the circuit already matches the backend topology, it is not remapped.
See: https://github.com/QISKit/qiskit-sdk-py/issues/342
"""
self.qp = QuantumProgram()
qr = self.qp.create_quantum_register('qr', 16)
cr = self.qp.create_classical_register('cr', 16)
qc = self.qp.create_circuit('native_cx', [qr], [cr])
qc.cx(qr[3], qr[14])
qc.cx(qr[5], qr[4])
qc.h(qr[9])
qc.cx(qr[9], qr[8])
qc.x(qr[11])
qc.cx(qr[3], qr[4])
qc.cx(qr[12], qr[11])
qc.cx(qr[13], qr[4])
for j in range(16):
qc.measure(qr[j], cr[j])
backend = 'local_qasm_simulator'
coupling_map = [[1, 0], [1, 2], [2, 3], [3, 4], [3, 14], [5, 4],
[6, 5], [6, 7], [6, 11], [7, 10], [8, 7], [9, 8],
[9, 10], [11, 10], [12, 5], [12, 11], [12, 13],
[13, 4], [13, 14], [15, 0], [15, 2], [15, 14]]
qobj = self.qp.compile(["native_cx"], backend=backend, coupling_map=coupling_map)
cx_qubits = [x["qubits"]
for x in qobj["circuits"][0]["compiled_circuit"]["operations"]
if x["name"] == "cx"]
self.assertEqual(sorted(cx_qubits), [[3, 4], [3, 14], [5, 4], [9, 8], [12, 11], [13, 4]])
class LocalUnitarySimulatorTest(QiskitTestCase):
"""Test local unitary simulator."""
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/example.qasm')
self.qp = QuantumProgram()
def tearDown(self):
pass
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
# strip measurements from circuit to avoid warnings
circuit['operations'] = [op for op in circuit['operations']
if op['name'] != 'measure']
# the simulator is expecting a JSON format, so we need to convert it
# back to JSON
qobj = {
'id': 'unitary',
'config': {
'max_credits': None,
'shots': 1,
'backend_name': 'local_unitary_simulator_py'
},
'circuits': [
{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': self.qp.get_qasm('example'),
'config': {
'coupling_map': None,
'basis_gates': None,
'layout': None,
'seed': None
}
}
]
}
# numpy.savetxt currently prints complex numbers in a way
# loadtxt can't read. To save file do,
# fmtstr=['% .4g%+.4gj' for i in range(numCols)]
# np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr,
# delimiter=',')
expected = np.loadtxt(self._get_resource_path('example_unitary_matrix.dat'),
dtype='complex', delimiter=',')
q_job = QuantumJob(qobj,
backend=UnitarySimulatorPy(),
preformatted=True)
result = UnitarySimulatorPy().run(q_job).result()
self.assertTrue(np.allclose(result.get_unitary('test'),
expected,
rtol=1e-3))
def test_two_unitary_simulator(self):
"""test running two circuits
This test is similar to one in test_quantumprogram but doesn't use
multiprocessing.
"""
qr = QuantumRegister(2)
cr = ClassicalRegister(1)
qc1 = QuantumCircuit(qr, cr)
qc2 = QuantumCircuit(qr, cr)
qc1.h(qr)
qc2.cx(qr[0], qr[1])
backend = UnitarySimulatorPy()
qobj = compile([qc1, qc2], backend=backend)
job = backend.run(QuantumJob(qobj, backend=backend, preformatted=True))
unitary1 = job.result().get_unitary(qc1)
unitary2 = job.result().get_unitary(qc2)
unitaryreal1 = np.array([[0.5, 0.5, 0.5, 0.5], [0.5, -0.5, 0.5, -0.5],
[0.5, 0.5, -0.5, -0.5],
[0.5, -0.5, -0.5, 0.5]])
unitaryreal2 = np.array([[1, 0, 0, 0], [0, 0, 0, 1],
[0., 0, 1, 0], [0, 1, 0, 0]])
norm1 = np.trace(np.dot(np.transpose(np.conj(unitaryreal1)), unitary1))
norm2 = np.trace(np.dot(np.transpose(np.conj(unitaryreal2)), unitary2))
self.assertAlmostEqual(norm1, 4)
self.assertAlmostEqual(norm2, 4)
def profile_unitary_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
n_circuits = 100
max_depth = 40
max_qubits = 5
pr = cProfile.Profile()
random_circuits = RandomQasmGenerator(seed=self.seed,
max_depth=max_depth,
max_qubits=max_qubits)
random_circuits.add_circuits(n_circuits, do_measure=False)
self.qp = random_circuits.get_program()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend=UnitarySimulatorPy())
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
self.log.info('------- start profiling UnitarySimulatorPy -----------')
ps.print_stats()
self.log.info(sout.getvalue())
self.log.info('------- stop profiling UnitarySimulatorPy -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
class LocalUnitarySimulatorTest(unittest.TestCase):
"""Test local unitary simulator."""
@classmethod
def setUpClass(cls):
cls.moduleName = os.path.splitext(__file__)[0]
cls.log = logging.getLogger(__name__)
cls.log.setLevel(logging.INFO)
logFileName = cls.moduleName + '.log'
handler = logging.FileHandler(logFileName)
handler.setLevel(logging.INFO)
log_fmt = ('{}.%(funcName)s:%(levelname)s:%(asctime)s:'
' %(message)s'.format(cls.__name__))
formatter = logging.Formatter(log_fmt)
handler.setFormatter(formatter)
cls.log.addHandler(handler)
def setUp(self):
self.seed = 88
self.qasmFileName = os.path.join(qiskit.__path__[0],
'../test/python/qasm/example.qasm')
self.modulePath = os.path.dirname(__file__)
self.qp = QuantumProgram()
def tearDown(self):
pass
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
shots = 1024
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
# if we want to manipulate the circuit, we have to convert it to a dict
circuit = json.loads(circuit.decode())
#strip measurements from circuit to avoid warnings
circuit['operations'] = [
op for op in circuit['operations'] if op['name'] != 'measure'
]
# the simulator is expecting a JSON format, so we need to convert it back to JSON
job = {'compiled_circuit': json.dumps(circuit).encode()}
# numpy savetxt is currently prints complex numbers in a way
# loadtxt can't read. To save file do,
# fmtstr=['% .4g%+.4gj' for i in range(numCols)]
# np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr, delimiter=',')
expected = np.loadtxt(os.path.join(self.modulePath,
'example_unitary_matrix.dat'),
dtype='complex',
delimiter=',')
result = UnitarySimulator(job).run()
self.assertTrue(
np.allclose(result['data']['unitary'], expected, rtol=1e-3))
def profile_unitary_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
nCircuits = 100
maxDepth = 40
maxQubits = 5
pr = cProfile.Profile()
randomCircuits = RandomQasmGenerator(seed=self.seed,
maxDepth=maxDepth,
maxQubits=maxQubits)
randomCircuits.add_circuits(nCircuits, doMeasure=False)
self.qp = randomCircuits.getProgram()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend='local_unitary_simulator')
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
self.log.info('------- start profiling UnitarySimulator -----------')
ps.print_stats()
self.log.info(sout.getvalue())
self.log.info('------- stop profiling UnitarySimulator -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
class LocalQasmSimulatorTest(unittest.TestCase):
"""Test local qasm simulator."""
@classmethod
def setUpClass(cls):
cls.moduleName = os.path.splitext(__file__)[0]
cls.pdf = PdfPages(cls.moduleName + '.pdf')
cls.log = logging.getLogger(__name__)
cls.log.setLevel(logging.INFO)
logFileName = cls.moduleName + '.log'
handler = logging.FileHandler(logFileName)
handler.setLevel(logging.INFO)
log_fmt = ('{}.%(funcName)s:%(levelname)s:%(asctime)s:'
' %(message)s'.format(cls.__name__))
formatter = logging.Formatter(log_fmt)
handler.setFormatter(formatter)
cls.log.addHandler(handler)
@classmethod
def tearDownClass(cls):
cls.pdf.close()
def setUp(self):
self.seed = 88
self.qasmFileName = os.path.join(qiskit.__path__[0],
'../test/python/qasm/example.qasm')
self.qp = QuantumProgram()
def tearDown(self):
pass
def test_qasm_simulator_single_shot(self):
"""Test single shot run."""
shots = 1
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': circuit, 'config': config}
result = QasmSimulator(job).run()
self.assertEqual(result['status'], 'DONE')
def test_qasm_simulator(self):
"""Test data counts output for single circuit run against reference."""
shots = 1024
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': circuit, 'config': config}
result = QasmSimulator(job).run()
expected = {'100 100': 137, '011 011': 131, '101 101': 117, '111 111': 127,
'000 000': 131, '010 010': 141, '110 110': 116, '001 001': 124}
self.assertEqual(result['data']['counts'], expected)
def test_if_statement(self):
self.log.info('test_if_statement_x')
shots = 100
max_qubits = 3
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', max_qubits)
cr = qp.create_classical_register('cr', max_qubits)
circuit = qp.create_circuit('test_if', [qr], [cr])
circuit.x(qr[0])
circuit.x(qr[1])
circuit.measure(qr[0], cr[0])
circuit.measure(qr[1], cr[1])
circuit.x(qr[2]).c_if(cr, 0x3)
circuit.measure(qr[0], cr[0])
circuit.measure(qr[1], cr[1])
circuit.measure(qr[2], cr[2])
circuit2 = qp.create_circuit('test_if_case_2', [qr], [cr])
circuit2.x(qr[0])
circuit2.measure(qr[0], cr[0])
circuit2.measure(qr[1], cr[1])
circuit2.x(qr[2]).c_if(cr, 0x3)
circuit2.measure(qr[0], cr[0])
circuit2.measure(qr[1], cr[1])
circuit2.measure(qr[2], cr[2])
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit = unroller.execute()
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_case_2')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit2 = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': ucircuit, 'config': config}
result_if_true = QasmSimulator(job).run()
job = {'compiled_circuit': ucircuit2, 'config': config}
result_if_false = QasmSimulator(job).run()
self.log.info('result_if_true circuit:')
self.log.info(circuit.qasm())
self.log.info('result_if_true={0}'.format(result_if_true))
del circuit.data[1]
self.log.info('result_if_false circuit:')
self.log.info(circuit.qasm())
self.log.info('result_if_false={0}'.format(result_if_false))
self.assertTrue(result_if_true['data']['counts']['111'] == 100)
self.assertTrue(result_if_false['data']['counts']['001'] == 100)
def test_teleport(self):
"""test teleportation as in tutorials"""
self.log.info('test_teleport')
pi = np.pi
shots = 1000
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 3)
cr0 = qp.create_classical_register('cr0', 1)
cr1 = qp.create_classical_register('cr1', 1)
cr2 = qp.create_classical_register('cr2', 1)
circuit = qp.create_circuit('teleport', [qr],
[cr0, cr1, cr2])
circuit.h(qr[1])
circuit.cx(qr[1], qr[2])
circuit.ry(pi/4, qr[0])
circuit.cx(qr[0], qr[1])
circuit.h(qr[0])
circuit.barrier(qr)
circuit.measure(qr[0], cr0[0])
circuit.measure(qr[1], cr1[0])
circuit.z(qr[2]).c_if(cr0, 1)
circuit.x(qr[2]).c_if(cr1, 1)
circuit.measure(qr[2], cr2[0])
backend = 'local_qasm_simulator'
qobj = qp.compile('teleport', backend=backend, shots=shots,
seed=self.seed)
results = qp.run(qobj)
data = results.get_counts('teleport')
alice = {}
bob = {}
alice['00'] = data['0 0 0'] + data['1 0 0']
alice['01'] = data['0 1 0'] + data['1 1 0']
alice['10'] = data['0 0 1'] + data['1 0 1']
alice['11'] = data['0 1 1'] + data['1 1 1']
bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1']
bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']
self.log.info('test_telport: circuit:')
self.log.info( circuit.qasm() )
self.log.info('test_teleport: data {0}'.format(data))
self.log.info('test_teleport: alice {0}'.format(alice))
self.log.info('test_teleport: bob {0}'.format(bob))
alice_ratio = 1/np.tan(pi/8)**2
bob_ratio = bob['0']/float(bob['1'])
error = abs(alice_ratio - bob_ratio) / alice_ratio
self.log.info('test_teleport: relative error = {0:.4f}'.format(error))
self.assertLess(error, 0.05)
def profile_qasm_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
seed = 88
shots = 1024
nCircuits = 100
minDepth = 1
maxDepth = 40
minQubits = 1
maxQubits = 5
pr = cProfile.Profile()
randomCircuits = RandomQasmGenerator(seed,
minQubits=minQubits,
maxQubits=maxQubits,
minDepth=minDepth,
maxDepth=maxDepth)
randomCircuits.add_circuits(nCircuits)
self.qp = randomCircuits.getProgram()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend='local_qasm_simulator',
shots=shots)
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
self.log.info('------- start profiling QasmSimulator -----------')
ps.print_stats()
self.log.info(sout.getvalue())
self.log.info('------- stop profiling QasmSimulator -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
def profile_nqubit_speed_grow_depth(self):
"""simulation time vs the number of qubits
where the circuit depth is 10x the number of simulated
qubits. Also creates a pdf file with this module name showing a
plot of the results. Compilation is not included in speed.
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
qubitRangeMax = 15
nQubitList = range(1,qubitRangeMax + 1)
nCircuits = 10
shots = 1024
seed = 88
maxTime = 30 # seconds; timing stops when simulation time exceeds this number
fmtStr1 = 'profile_nqubit_speed::nqubits:{0}, backend:{1}, elapsed_time:{2:.2f}'
fmtStr2 = 'backend:{0}, circuit:{1}, numOps:{2}, result:{3}'
fmtStr3 = 'minDepth={minDepth}, maxDepth={maxDepth}, num circuits={nCircuits}, shots={shots}'
backendList = ['local_qasm_simulator', 'local_unitary_simulator']
if shutil.which('qasm_simulator'):
backendList.append('local_qasm_cpp_simulator')
else:
self.log.info('profile_nqubit_speed::\"qasm_simulator\" executable not in path...skipping')
fig = plt.figure(0)
plt.clf()
ax = fig.add_axes((0.1, 0.25, 0.8, 0.6))
for i, backend in enumerate(backendList):
elapsedTime = np.zeros(len(nQubitList))
if backend is 'local_unitary_simulator':
doMeasure = False
else:
doMeasure = True
j, timedOut = 0, False
while j < qubitRangeMax and not timedOut:
nQubits = nQubitList[j]
randomCircuits = RandomQasmGenerator(seed,
minQubits=nQubits,
maxQubits=nQubits,
minDepth=nQubits*10,
maxDepth=nQubits*10)
randomCircuits.add_circuits(nCircuits, doMeasure=doMeasure)
qp = randomCircuits.getProgram()
cnames = qp.get_circuit_names()
qobj = qp.compile(cnames, backend=backend, shots=shots,
seed=seed)
start = time.perf_counter()
results = qp.run(qobj)
stop = time.perf_counter()
elapsedTime[j] = stop - start
if elapsedTime[j] > maxTime:
timedOut = True
self.log.info(fmtStr1.format(nQubits, backend, elapsedTime[j]))
if backend is not 'local_unitary_simulator':
for name in cnames:
self.log.info(fmtStr2.format(
backend, name, len(qp.get_circuit(name)),
results.get_data(name)))
j += 1
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
if backend is 'local_unitary_simulator':
ax.plot(nQubitList[:j], elapsedTime[:j], label=backend, marker='o')
else:
ax.plot(nQubitList[:j], elapsedTime[:j]/shots, label=backend,
marker='o')
ax.set_yscale('log', basey=10)
ax.set_xlabel('number of qubits')
ax.set_ylabel('process time/shot')
ax.set_title('profile_nqubit_speed_grow_depth')
fig.text(0.1, 0.05,
fmtStr3.format(minDepth='10*nQubits', maxDepth='10*nQubits',
nCircuits=nCircuits, shots=shots))
ax.legend()
self.pdf.savefig(fig)
def profile_nqubit_speed_constant_depth(self):
"""simulation time vs the number of qubits
where the circuit depth is fixed at 40. Also creates a pdf file
with this module name showing a plot of the results. Compilation
is not included in speed.
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
qubitRangeMax = 15
nQubitList = range(1,qubitRangeMax + 1)
maxDepth = 40
minDepth = 40
nCircuits = 10
shots = 1024
seed = 88
maxTime = 30 # seconds; timing stops when simulation time exceeds this number
fmtStr1 = 'profile_nqubit_speed::nqubits:{0}, backend:{1}, elapsed_time:{2:.2f}'
fmtStr2 = 'backend:{0}, circuit:{1}, numOps:{2}, result:{3}'
fmtStr3 = 'minDepth={minDepth}, maxDepth={maxDepth}, num circuits={nCircuits}, shots={shots}'
backendList = ['local_qasm_simulator', 'local_unitary_simulator']
if shutil.which('qasm_simulator'):
backendList.append('local_qasm_cpp_simulator')
else:
self.log.info('profile_nqubit_speed::\"qasm_simulator\" executable not in path...skipping')
fig = plt.figure(0)
plt.clf()
ax = fig.add_axes((0.1, 0.2, 0.8, 0.6))
for i, backend in enumerate(backendList):
elapsedTime = np.zeros(len(nQubitList))
if backend is 'local_unitary_simulator':
doMeasure = False
else:
doMeasure = True
j, timedOut = 0, False
while j < qubitRangeMax and not timedOut:
nQubits = nQubitList[j]
randomCircuits = RandomQasmGenerator(seed,
minQubits=nQubits,
maxQubits=nQubits,
minDepth=minDepth,
maxDepth=maxDepth)
randomCircuits.add_circuits(nCircuits, doMeasure=doMeasure)
qp = randomCircuits.getProgram()
cnames = qp.get_circuit_names()
qobj = qp.compile(cnames, backend=backend, shots=shots, seed=seed)
start = time.perf_counter()
results = qp.run(qobj)
stop = time.perf_counter()
elapsedTime[j] = stop - start
if elapsedTime[j] > maxTime:
timedOut = True
self.log.info(fmtStr1.format(nQubits, backend, elapsedTime[j]))
if backend is not 'local_unitary_simulator':
for name in cnames:
self.log.info(fmtStr2.format(
backend, name, len(qp.get_circuit(name)),
results.get_data(name)))
j += 1
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
if backend is 'local_unitary_simulator':
ax.plot(nQubitList[:j], elapsedTime[:j], label=backend, marker='o')
else:
ax.plot(nQubitList[:j], elapsedTime[:j]/shots, label=backend,
marker='o')
ax.set_yscale('log', basey=10)
ax.set_xlabel('number of qubits')
ax.set_ylabel('process time/shot')
ax.set_title('profile_nqubit_speed_constant_depth')
fig.text(0.1, 0.05,
fmtStr3.format(minDepth=minDepth, maxDepth=maxDepth,
nCircuits=nCircuits, shots=shots))
ax.legend()
self.pdf.savefig(fig)
class LocalSimulatorTest(unittest.TestCase):
"""
Test interface to local simulators.
"""
@classmethod
def setUpClass(cls):
cls.moduleName = os.path.splitext(__file__)[0]
cls.logFileName = cls.moduleName + '.log'
log_fmt = 'LocalSimulatorTest:%(levelname)s:%(asctime)s: %(message)s'
logging.basicConfig(filename=cls.logFileName,
level=logging.INFO,
format=log_fmt)
@classmethod
def tearDownClass(cls):
#cls.pdf.close()
pass
def setUp(self):
self.seed = 88
self.qasmFileName = os.path.join(qiskit.__path__[0],
'../test/python/qasm/example.qasm')
self.qp = QuantumProgram()
shots = 1
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
self.job = {
'compiled_circuit': circuit,
'config': {
'shots': shots,
'seed': random.randint(0, 10)
}
}
def tearDown(self):
pass
def test_local_configuration_present(self):
self.assertTrue(_localsimulator.local_configuration)
def test_local_configurations(self):
required_keys = [
'name', 'url', 'simulator', 'description', 'coupling_map',
'basis_gates'
]
for conf in _localsimulator.local_configuration:
for key in required_keys:
self.assertIn(key, conf.keys())
def test_simulator_classes(self):
cdict = _localsimulator._simulator_classes
cdict = getattr(_localsimulator, '_simulator_classes')
logging.info('found local simulators: {0}'.format(repr(cdict)))
self.assertTrue(cdict)
def test_local_backends(self):
backends = _localsimulator.local_backends()
logging.info('found local backends: {0}'.format(repr(backends)))
self.assertTrue(backends)
def test_instantiation(self):
"""
Test instantiation of LocalSimulator
"""
backend_list = _localsimulator.local_backends()
for backend_name in backend_list:
backend = _localsimulator.LocalSimulator(backend_name, self.job)
class LocalQasmSimulatorTest(unittest.TestCase):
"""Test local qasm simulator."""
@classmethod
def setUpClass(cls):
cls.moduleName = os.path.splitext(__file__)[0]
cls.pdf = PdfPages(cls.moduleName + '.pdf')
cls.log = logging.getLogger(__name__)
cls.log.setLevel(logging.INFO)
logFileName = cls.moduleName + '.log'
handler = logging.FileHandler(logFileName)
handler.setLevel(logging.INFO)
log_fmt = ('{}.%(funcName)s:%(levelname)s:%(asctime)s:'
' %(message)s'.format(cls.__name__))
formatter = logging.Formatter(log_fmt)
handler.setFormatter(formatter)
cls.log.addHandler(handler)
@classmethod
def tearDownClass(cls):
cls.pdf.close()
def setUp(self):
self.seed = 88
self.qasmFileName = os.path.join(qiskit.__path__[0],
'../test/python/qasm/example.qasm')
self.qp = QuantumProgram()
def tearDown(self):
pass
def test_qasm_simulator_single_shot(self):
"""Test single shot run."""
shots = 1
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': circuit, 'config': config}
result = QasmSimulator(job).run()
self.assertEqual(result['status'], 'DONE')
def test_qasm_simulator(self):
"""Test data counts output for single circuit run against reference."""
shots = 1024
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': circuit, 'config': config}
result = QasmSimulator(job).run()
expected = {
'100 100': 137,
'011 011': 131,
'101 101': 117,
'111 111': 127,
'000 000': 131,
'010 010': 141,
'110 110': 116,
'001 001': 124
}
self.assertEqual(result['data']['counts'], expected)
def test_if_statement(self):
self.log.info('test_if_statement_x')
shots = 100
max_qubits = 3
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', max_qubits)
cr = qp.create_classical_register('cr', max_qubits)
circuit = qp.create_circuit('test_if', [qr], [cr])
circuit.x(qr[0])
circuit.x(qr[1])
circuit.measure(qr[0], cr[0])
circuit.measure(qr[1], cr[1])
circuit.x(qr[2]).c_if(cr, 0x3)
circuit.measure(qr[0], cr[0])
circuit.measure(qr[1], cr[1])
circuit.measure(qr[2], cr[2])
circuit2 = qp.create_circuit('test_if_case_2', [qr], [cr])
circuit2.x(qr[0])
circuit2.measure(qr[0], cr[0])
circuit2.measure(qr[1], cr[1])
circuit2.x(qr[2]).c_if(cr, 0x3)
circuit2.measure(qr[0], cr[0])
circuit2.measure(qr[1], cr[1])
circuit2.measure(qr[2], cr[2])
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit = unroller.execute()
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_case_2')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit2 = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': ucircuit, 'config': config}
result_if_true = QasmSimulator(job).run()
job = {'compiled_circuit': ucircuit2, 'config': config}
result_if_false = QasmSimulator(job).run()
self.log.info('result_if_true circuit:')
self.log.info(circuit.qasm())
self.log.info('result_if_true={0}'.format(result_if_true))
del circuit.data[1]
self.log.info('result_if_false circuit:')
self.log.info(circuit.qasm())
self.log.info('result_if_false={0}'.format(result_if_false))
self.assertTrue(result_if_true['data']['counts']['111'] == 100)
self.assertTrue(result_if_false['data']['counts']['001'] == 100)
def test_teleport(self):
"""test teleportation as in tutorials"""
self.log.info('test_teleport')
pi = np.pi
shots = 1000
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 3)
cr0 = qp.create_classical_register('cr0', 1)
cr1 = qp.create_classical_register('cr1', 1)
cr2 = qp.create_classical_register('cr2', 1)
circuit = qp.create_circuit('teleport', [qr], [cr0, cr1, cr2])
circuit.h(qr[1])
circuit.cx(qr[1], qr[2])
circuit.ry(pi / 4, qr[0])
circuit.cx(qr[0], qr[1])
circuit.h(qr[0])
circuit.barrier(qr)
circuit.measure(qr[0], cr0[0])
circuit.measure(qr[1], cr1[0])
circuit.z(qr[2]).c_if(cr0, 1)
circuit.x(qr[2]).c_if(cr1, 1)
circuit.measure(qr[2], cr2[0])
backend = 'local_qasm_simulator'
qobj = qp.compile('teleport',
backend=backend,
shots=shots,
seed=self.seed)
results = qp.run(qobj)
data = results.get_counts('teleport')
alice = {}
bob = {}
alice['00'] = data['0 0 0'] + data['1 0 0']
alice['01'] = data['0 1 0'] + data['1 1 0']
alice['10'] = data['0 0 1'] + data['1 0 1']
alice['11'] = data['0 1 1'] + data['1 1 1']
bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1']
bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']
self.log.info('test_telport: circuit:')
self.log.info(circuit.qasm())
self.log.info('test_teleport: data {0}'.format(data))
self.log.info('test_teleport: alice {0}'.format(alice))
self.log.info('test_teleport: bob {0}'.format(bob))
alice_ratio = 1 / np.tan(pi / 8)**2
bob_ratio = bob['0'] / float(bob['1'])
error = abs(alice_ratio - bob_ratio) / alice_ratio
self.log.info('test_teleport: relative error = {0:.4f}'.format(error))
self.assertLess(error, 0.05)
def profile_qasm_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
seed = 88
shots = 1024
nCircuits = 100
minDepth = 1
maxDepth = 40
minQubits = 1
maxQubits = 5
pr = cProfile.Profile()
randomCircuits = RandomQasmGenerator(seed,
minQubits=minQubits,
maxQubits=maxQubits,
minDepth=minDepth,
maxDepth=maxDepth)
randomCircuits.add_circuits(nCircuits)
self.qp = randomCircuits.getProgram()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend='local_qasm_simulator',
shots=shots)
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
self.log.info('------- start profiling QasmSimulator -----------')
ps.print_stats()
self.log.info(sout.getvalue())
self.log.info('------- stop profiling QasmSimulator -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
def profile_nqubit_speed_grow_depth(self):
"""simulation time vs the number of qubits
where the circuit depth is 10x the number of simulated
qubits. Also creates a pdf file with this module name showing a
plot of the results. Compilation is not included in speed.
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
qubitRangeMax = 15
nQubitList = range(1, qubitRangeMax + 1)
nCircuits = 10
shots = 1024
seed = 88
maxTime = 30 # seconds; timing stops when simulation time exceeds this number
fmtStr1 = 'profile_nqubit_speed::nqubits:{0}, backend:{1}, elapsed_time:{2:.2f}'
fmtStr2 = 'backend:{0}, circuit:{1}, numOps:{2}, result:{3}'
fmtStr3 = 'minDepth={minDepth}, maxDepth={maxDepth}, num circuits={nCircuits}, shots={shots}'
backendList = ['local_qasm_simulator', 'local_unitary_simulator']
if shutil.which('qasm_simulator'):
backendList.append('local_qasm_cpp_simulator')
else:
self.log.info(
'profile_nqubit_speed::\"qasm_simulator\" executable not in path...skipping'
)
fig = plt.figure(0)
plt.clf()
ax = fig.add_axes((0.1, 0.25, 0.8, 0.6))
for i, backend in enumerate(backendList):
elapsedTime = np.zeros(len(nQubitList))
if backend is 'local_unitary_simulator':
doMeasure = False
else:
doMeasure = True
j, timedOut = 0, False
while j < qubitRangeMax and not timedOut:
nQubits = nQubitList[j]
randomCircuits = RandomQasmGenerator(seed,
minQubits=nQubits,
maxQubits=nQubits,
minDepth=nQubits * 10,
maxDepth=nQubits * 10)
randomCircuits.add_circuits(nCircuits, doMeasure=doMeasure)
qp = randomCircuits.getProgram()
cnames = qp.get_circuit_names()
qobj = qp.compile(cnames,
backend=backend,
shots=shots,
seed=seed)
start = time.perf_counter()
results = qp.run(qobj)
stop = time.perf_counter()
elapsedTime[j] = stop - start
if elapsedTime[j] > maxTime:
timedOut = True
self.log.info(fmtStr1.format(nQubits, backend, elapsedTime[j]))
if backend is not 'local_unitary_simulator':
for name in cnames:
self.log.info(
fmtStr2.format(backend, name,
len(qp.get_circuit(name)),
results.get_data(name)))
j += 1
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
if backend is 'local_unitary_simulator':
ax.plot(nQubitList[:j],
elapsedTime[:j],
label=backend,
marker='o')
else:
ax.plot(nQubitList[:j],
elapsedTime[:j] / shots,
label=backend,
marker='o')
ax.set_yscale('log', basey=10)
ax.set_xlabel('number of qubits')
ax.set_ylabel('process time/shot')
ax.set_title('profile_nqubit_speed_grow_depth')
fig.text(
0.1, 0.05,
fmtStr3.format(minDepth='10*nQubits',
maxDepth='10*nQubits',
nCircuits=nCircuits,
shots=shots))
ax.legend()
self.pdf.savefig(fig)
def profile_nqubit_speed_constant_depth(self):
"""simulation time vs the number of qubits
where the circuit depth is fixed at 40. Also creates a pdf file
with this module name showing a plot of the results. Compilation
is not included in speed.
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
qubitRangeMax = 15
nQubitList = range(1, qubitRangeMax + 1)
maxDepth = 40
minDepth = 40
nCircuits = 10
shots = 1024
seed = 88
maxTime = 30 # seconds; timing stops when simulation time exceeds this number
fmtStr1 = 'profile_nqubit_speed::nqubits:{0}, backend:{1}, elapsed_time:{2:.2f}'
fmtStr2 = 'backend:{0}, circuit:{1}, numOps:{2}, result:{3}'
fmtStr3 = 'minDepth={minDepth}, maxDepth={maxDepth}, num circuits={nCircuits}, shots={shots}'
backendList = ['local_qasm_simulator', 'local_unitary_simulator']
if shutil.which('qasm_simulator'):
backendList.append('local_qasm_cpp_simulator')
else:
self.log.info(
'profile_nqubit_speed::\"qasm_simulator\" executable not in path...skipping'
)
fig = plt.figure(0)
plt.clf()
ax = fig.add_axes((0.1, 0.2, 0.8, 0.6))
for i, backend in enumerate(backendList):
elapsedTime = np.zeros(len(nQubitList))
if backend is 'local_unitary_simulator':
doMeasure = False
else:
doMeasure = True
j, timedOut = 0, False
while j < qubitRangeMax and not timedOut:
nQubits = nQubitList[j]
randomCircuits = RandomQasmGenerator(seed,
minQubits=nQubits,
maxQubits=nQubits,
minDepth=minDepth,
maxDepth=maxDepth)
randomCircuits.add_circuits(nCircuits, doMeasure=doMeasure)
qp = randomCircuits.getProgram()
cnames = qp.get_circuit_names()
qobj = qp.compile(cnames,
backend=backend,
shots=shots,
seed=seed)
start = time.perf_counter()
results = qp.run(qobj)
stop = time.perf_counter()
elapsedTime[j] = stop - start
if elapsedTime[j] > maxTime:
timedOut = True
self.log.info(fmtStr1.format(nQubits, backend, elapsedTime[j]))
if backend is not 'local_unitary_simulator':
for name in cnames:
self.log.info(
fmtStr2.format(backend, name,
len(qp.get_circuit(name)),
results.get_data(name)))
j += 1
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
if backend is 'local_unitary_simulator':
ax.plot(nQubitList[:j],
elapsedTime[:j],
label=backend,
marker='o')
else:
ax.plot(nQubitList[:j],
elapsedTime[:j] / shots,
label=backend,
marker='o')
ax.set_yscale('log', basey=10)
ax.set_xlabel('number of qubits')
ax.set_ylabel('process time/shot')
ax.set_title('profile_nqubit_speed_constant_depth')
fig.text(
0.1, 0.05,
fmtStr3.format(minDepth=minDepth,
maxDepth=maxDepth,
nCircuits=nCircuits,
shots=shots))
ax.legend()
self.pdf.savefig(fig)
class MapperTest(QiskitTestCase):
"""Test the mapper."""
def setUp(self):
self.seed = 42
self.qp = QuantumProgram()
def test_mapper_overoptimization(self):
"""
The mapper should not change the semantics of the input. An overoptimization introduced
the issue #81: https://github.com/QISKit/qiskit-sdk-py/issues/81
"""
self.qp.load_qasm_file(
self._get_resource_path('qasm/overoptimization.qasm'), name='test')
coupling_map = {0: [2], 1: [2], 2: [3], 3: []}
result1 = self.qp.execute(["test"],
backend="local_qasm_simulator",
coupling_map=coupling_map)
count1 = result1.get_counts("test")
result2 = self.qp.execute(["test"],
backend="local_qasm_simulator",
coupling_map=None)
count2 = result2.get_counts("test")
self.assertEqual(
count1.keys(),
count2.keys(),
)
def test_math_domain_error(self):
"""
The math library operates over floats and introduce floating point errors that should be
avoided.
See: https://github.com/QISKit/qiskit-sdk-py/issues/111
"""
self.qp.load_qasm_file(
self._get_resource_path('qasm/math_domain_error.qasm'),
name='test')
coupling_map = {0: [2], 1: [2], 2: [3], 3: []}
result1 = self.qp.execute(["test"],
backend="local_qasm_simulator",
coupling_map=coupling_map,
seed=self.seed)
# TODO: the circuit produces different results under different versions
# of Python, which defeats the purpose of the "seed" parameter. A proper
# fix should be issued - this is a workaround for this particular test.
if version_info.minor == 5: # Python 3.5
self.assertEqual(result1.get_counts("test"), {
'0001': 507,
'0101': 517
})
else: # Python 3.6 and higher
self.assertEqual(result1.get_counts("test"), {
'0001': 517,
'0101': 507
})
def test_optimize_1q_gates_issue159(self):
"""Test change in behavior for optimize_1q_gates that removes u1(2*pi) rotations.
See: https://github.com/QISKit/qiskit-sdk-py/issues/159
"""
self.qp = QuantumProgram()
qr = self.qp.create_quantum_register('qr', 2)
cr = self.qp.create_classical_register('cr', 2)
qc = self.qp.create_circuit('Bell', [qr], [cr])
qc.h(qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.cx(qr[1], qr[0])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
backend = 'local_qasm_simulator'
cmap = {1: [0], 2: [0, 1, 4], 3: [2, 4]}
qobj = self.qp.compile(["Bell"], backend=backend, coupling_map=cmap)
# TODO: Python 3.5 produces an equivalent but different QASM, with the
# last lines swapped. This assertion compares the output with the two
# expected programs, but proper revision should be done.
self.assertIn(self.qp.get_compiled_qasm(qobj, "Bell"),
(EXPECTED_QASM_1Q_GATES, EXPECTED_QASM_1Q_GATES_3_5))
def test_random_parameter_circuit(self):
"""Run a circuit with randomly generated parameters."""
self.qp.load_qasm_file(
self._get_resource_path('qasm/random_n5_d5.qasm'), name='rand')
coupling_map = {0: [1], 1: [2], 2: [3], 3: [4]}
result1 = self.qp.execute(["rand"],
backend="local_qasm_simulator",
coupling_map=coupling_map,
seed=self.seed)
res = result1.get_counts("rand")
expected_result = {
'10000': 97,
'00011': 24,
'01000': 120,
'10111': 59,
'01111': 37,
'11010': 14,
'00001': 34,
'00100': 42,
'10110': 41,
'00010': 102,
'00110': 48,
'10101': 19,
'01101': 61,
'00111': 46,
'11100': 28,
'01100': 1,
'00000': 86,
'11111': 14,
'11011': 9,
'10010': 35,
'10100': 20,
'01001': 21,
'01011': 19,
'10011': 10,
'11001': 13,
'00101': 4,
'01010': 2,
'01110': 17,
'11000': 1
}
# TODO: the circuit produces different results under different versions
# of Python and NetworkX package, which defeats the purpose of the
# "seed" parameter. A proper fix should be issued - this is a workaround
# for this particular test.
if version_info.minor == 5: # Python 3.5
import networkx
if networkx.__version__ == '1.11':
expected_result = {
'01001': 41,
'10010': 25,
'00111': 53,
'01101': 68,
'10101': 11,
'10110': 34,
'01110': 6,
'11100': 27,
'00100': 54,
'11010': 20,
'10100': 20,
'01100': 1,
'10000': 96,
'11000': 1,
'11011': 9,
'10011': 15,
'00101': 3,
'00001': 25,
'00010': 113,
'01011': 16,
'11111': 19,
'11001': 16,
'00011': 22,
'00000': 89,
'00110': 40,
'01000': 110,
'10111': 60,
'11110': 4,
'01010': 9,
'01111': 17
}
else:
expected_result = {
'01001': 32,
'11110': 1,
'10010': 36,
'11100': 34,
'11011': 10,
'00001': 41,
'00000': 83,
'10000': 94,
'11001': 15,
'01011': 24,
'00100': 43,
'11000': 5,
'11010': 9,
'01100': 5,
'10100': 23,
'01101': 54,
'01110': 6,
'00011': 13,
'10101': 12,
'00111': 36,
'00110': 40,
'01000': 119,
'11111': 19,
'01010': 8,
'10111': 61,
'10110': 52,
'01111': 23,
'00010': 110,
'00101': 2,
'10011': 14
}
self.assertEqual(res, expected_result)
def test_symbolic_unary(self):
"""Test symbolic math in DAGBackend and optimizer with a prefix.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_unary.qasm')).parse()
unr = unroll.Unroller(ast,
backend=unroll.DAGBackend(
["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_UNARY)
def test_symbolic_binary(self):
"""Test symbolic math in DAGBackend and optimizer with a binary operation.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_binary.qasm')).parse()
unr = unroll.Unroller(ast,
backend=unroll.DAGBackend(
["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_BINARY)
def test_symbolic_extern(self):
"""Test symbolic math in DAGBackend and optimizer with an external function.
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(filename=self._get_resource_path(
'qasm/issue172_extern.qasm')).parse()
unr = unroll.Unroller(ast,
backend=unroll.DAGBackend(
["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_EXTERN)
def test_symbolic_power(self):
"""Test symbolic math in DAGBackend and optimizer with a power (^).
See: https://github.com/QISKit/qiskit-sdk-py/issues/172
"""
ast = qasm.Qasm(data=QASM_SYMBOLIC_POWER).parse()
unr = unroll.Unroller(ast,
backend=unroll.DAGBackend(
["cx", "u1", "u2", "u3"]))
unr.execute()
circ = mapper.optimize_1q_gates(unr.backend.circuit)
self.assertEqual(circ.qasm(qeflag=True), EXPECTED_QASM_SYMBOLIC_POWER)
class LocalUnitarySimulatorTest(QiskitTestCase):
"""Test local unitary simulator."""
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/example.qasm')
self.qp = QuantumProgram()
def tearDown(self):
pass
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
# strip measurements from circuit to avoid warnings
circuit['operations'] = [
op for op in circuit['operations'] if op['name'] != 'measure'
]
# the simulator is expecting a JSON format, so we need to convert it
# back to JSON
qobj = {
'id':
'unitary',
'config': {
'max_credits': None,
'shots': 1,
'backend_name': 'local_unitary_simulator_py'
},
'circuits': [{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': self.qp.get_qasm('example'),
'config': {
'coupling_map': None,
'basis_gates': None,
'layout': None,
'seed': None
}
}]
}
# numpy.savetxt currently prints complex numbers in a way
# loadtxt can't read. To save file do,
# fmtstr=['% .4g%+.4gj' for i in range(numCols)]
# np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr,
# delimiter=',')
expected = np.loadtxt(
self._get_resource_path('example_unitary_matrix.dat'),
dtype='complex',
delimiter=',')
q_job = QuantumJob(qobj,
backend=UnitarySimulatorPy(),
preformatted=True)
result = UnitarySimulatorPy().run(q_job).result()
self.assertTrue(
np.allclose(result.get_unitary('test'), expected, rtol=1e-3))
def test_two_unitary_simulator(self):
"""test running two circuits
This test is similar to one in test_quantumprogram but doesn't use
multiprocessing.
"""
qr = QuantumRegister(2)
cr = ClassicalRegister(1)
qc1 = QuantumCircuit(qr, cr)
qc2 = QuantumCircuit(qr, cr)
qc1.h(qr)
qc2.cx(qr[0], qr[1])
backend = UnitarySimulatorPy()
qobj = compile([qc1, qc2], backend=backend)
job = backend.run(QuantumJob(qobj, backend=backend, preformatted=True))
unitary1 = job.result().get_unitary(qc1)
unitary2 = job.result().get_unitary(qc2)
unitaryreal1 = np.array([[0.5, 0.5, 0.5, 0.5], [0.5, -0.5, 0.5, -0.5],
[0.5, 0.5, -0.5, -0.5],
[0.5, -0.5, -0.5, 0.5]])
unitaryreal2 = np.array([[1, 0, 0, 0], [0, 0, 0, 1], [0., 0, 1, 0],
[0, 1, 0, 0]])
norm1 = np.trace(np.dot(np.transpose(np.conj(unitaryreal1)), unitary1))
norm2 = np.trace(np.dot(np.transpose(np.conj(unitaryreal2)), unitary2))
self.assertAlmostEqual(norm1, 4)
self.assertAlmostEqual(norm2, 4)
def profile_unitary_simulator(self):
"""Profile randomly generated circuits.
Writes profile results to <this_module>.prof as well as recording
to the log file.
number of circuits = 100.
number of operations/circuit in [1, 40]
number of qubits in [1, 5]
"""
n_circuits = 100
max_depth = 40
max_qubits = 5
pr = cProfile.Profile()
random_circuits = RandomQasmGenerator(seed=self.seed,
max_depth=max_depth,
max_qubits=max_qubits)
random_circuits.add_circuits(n_circuits, do_measure=False)
self.qp = random_circuits.get_program()
pr.enable()
self.qp.execute(self.qp.get_circuit_names(),
backend=UnitarySimulatorPy())
pr.disable()
sout = io.StringIO()
ps = pstats.Stats(pr, stream=sout).sort_stats('cumulative')
self.log.info('------- start profiling UnitarySimulatorPy -----------')
ps.print_stats()
self.log.info(sout.getvalue())
self.log.info('------- stop profiling UnitarySimulatorPy -----------')
sout.close()
pr.dump_stats(self.moduleName + '.prof')
class UnitarySimulatorSympyTest(QiskitTestCase):
"""Test local unitary simulator sympy."""
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/simple.qasm')
self.qp = QuantumProgram()
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
# strip measurements from circuit to avoid warnings
circuit['operations'] = [
op for op in circuit['operations'] if op['name'] != 'measure'
]
# the simulator is expecting a JSON format, so we need to convert it
# back to JSON
qobj = {
'id':
'unitary',
'config': {
'max_credits': None,
'shots': 1,
'backend_name': 'local_sympy_unitary_simulator'
},
'circuits': [{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': self.qp.get_qasm('example'),
'config': {
'coupling_map': None,
'basis_gates': None,
'layout': None,
'seed': None
}
}]
}
q_job = QuantumJob(qobj,
backend=UnitarySimulatorSympy(),
preformatted=True)
result = UnitarySimulatorSympy().run(q_job).result()
actual = result.get_data('test')['unitary']
self.assertEqual(actual[0][0], sqrt(2) / 2)
self.assertEqual(actual[0][1], sqrt(2) / 2)
self.assertEqual(actual[0][2], 0)
self.assertEqual(actual[0][3], 0)
self.assertEqual(actual[1][0], 0)
self.assertEqual(actual[1][1], 0)
self.assertEqual(actual[1][2], sqrt(2) / 2)
self.assertEqual(actual[1][3], -sqrt(2) / 2)
self.assertEqual(actual[2][0], 0)
self.assertEqual(actual[2][1], 0)
self.assertEqual(actual[2][2], sqrt(2) / 2)
self.assertEqual(actual[2][3], sqrt(2) / 2)
self.assertEqual(actual[3][0], sqrt(2) / 2)
self.assertEqual(actual[3][1], -sqrt(2) / 2)
self.assertEqual(actual[3][2], 0)
self.assertEqual(actual[3][3], 0)
