scnc
/
qiskit
mirror of https://github.com/Qiskit/qiskit.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove aer provider tests (#2201) 

These tests haven't run in a long time, they skip (not silently but
among all the test results no one notices) They also don't work
currently even if we fix the original breakage. If we're not
cross-testing terra master on aer and vice versa keep these tests in
terra don't provide value (although travis and appveyor limit how much
we can do there). We can revisit adding them back in the future if
needed.
This commit is contained in:
Matthew Treinish 2019-04-30 00:32:31 -04:00 committed by Ali Javadi-Abhari
parent 6623e99c17
commit 018289a92b
7 changed files with 0 additions and 509 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
test/python/aer_provider_integration_test/__init__.py
View File

@ -1,8 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
"""Qiskit Aer integration tests. These can be removed if they are covered in Aer"""

59
test/python/aer_provider_integration_test/test_aer_qobj_headers.py
View File

@ -1,59 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
"""Tests for all BasicAer simulators."""
import unittest
import qiskit
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile, assemble
from qiskit.qobj import QobjHeader
from qiskit.test import QiskitTestCase, requires_aer_provider
@requires_aer_provider
class TestBasicAerQobj(QiskitTestCase):
"""Tests for all the Terra simulators."""
def setUp(self):
super().setUp()
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
self.qc1 = QuantumCircuit(qr, cr, name='circuit0')
self.qc1.h(qr[0])
def test_qobj_headers_in_result(self):
"""Test that the qobj headers are passed onto the results."""
custom_qobj_header = {'x': 1, 'y': [1, 2, 3], 'z': {'a': 4}}
for backend in qiskit.providers.aer.Aer.backends():
with self.subTest(backend=backend):
qc1_new = transpile(self.qc1, backend=backend)
qobj = assemble(qc1_new, shots=1000)
# Update the Qobj header.
qobj.header = QobjHeader.from_dict(custom_qobj_header)
# Update the Qobj.experiment header.
qobj.experiments[0].header.some_field = 'extra info'
result = backend.run(qobj).result()
self.assertEqual(result.header.to_dict(), custom_qobj_header)
self.assertEqual(result.results[0].header.some_field,
'extra info')
@unittest.skip("skipping as aer does not support. I made an issue")
def test_job_qobj(self):
"""Test job.qobj()."""
for backend in qiskit.providers.aer.Aer.backends():
with self.subTest(backend=backend):
qc1_new = transpile(self.qc1, backend=backend)
qobj = assemble(qc1_new, shots=1000)
job = backend.run(qobj)
self.assertEqual(job.qobj(), qobj)

54
test/python/aer_provider_integration_test/test_extensions_simulator.py
View File

@ -1,54 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
# pylint: disable=unused-import
"""Tests for verifying the correctness of simulator extension instructions."""
import unittest
import qiskit
import qiskit.extensions.simulator
from qiskit.quantum_info import state_fidelity
from qiskit.result.postprocess import format_statevector
from qiskit import execute
from qiskit.test import QiskitTestCase, requires_aer_provider
@requires_aer_provider
class TestExtensionsSimulator(QiskitTestCase):
"""Test instruction extensions for basicaer simulators:
save, load, noise, snapshot, wait
"""
_desired_fidelity = 0.99
def test_snapshot(self):
"""snapshot a bell state in the middle of circuit"""
basis_gates = ['cx', 'u1', 'u2', 'u3', 'snapshot']
qr = qiskit.QuantumRegister(2)
cr = qiskit.ClassicalRegister(2)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.snapshot('3')
circuit.cx(qr[0], qr[1])
circuit.h(qr[1])
sim = qiskit.providers.aer.StatevectorSimulator()
result = execute(circuit, sim, basis_gates=basis_gates).result()
# TODO: rely on Result.get_statevector() postprocessing rather than manual
snapshots = result.data(0)['snapshots']['statevector']['3']
snapshot = format_statevector(snapshots[0])
target = [0.70710678 + 0.j, 0. + 0.j, 0. + 0.j, 0.70710678 + 0.j]
fidelity = state_fidelity(snapshot, target)
self.assertGreater(
fidelity, self._desired_fidelity,
"snapshot has low fidelity{0:.2g}.".format(fidelity))
if __name__ == '__main__':
unittest.main(verbosity=2)

57
test/python/aer_provider_integration_test/test_multi_registers_convention.py
View File

@ -1,57 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
"""Test Qiskit's QuantumCircuit class for multiple registers."""
import qiskit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import execute
from qiskit.quantum_info import state_fidelity, process_fidelity, Pauli, basis_state
from qiskit.test import QiskitTestCase, requires_aer_provider
class TestCircuitMultiRegs(QiskitTestCase):
"""QuantumCircuit Qasm tests."""
@requires_aer_provider
def test_circuit_multi(self):
"""Test circuit multi regs declared at start.
"""
qreg0 = QuantumRegister(2, 'q0')
creg0 = ClassicalRegister(2, 'c0')
qreg1 = QuantumRegister(2, 'q1')
creg1 = ClassicalRegister(2, 'c1')
circ = QuantumCircuit(qreg0, qreg1)
circ.x(qreg0[1])
circ.x(qreg1[0])
meas = QuantumCircuit(qreg0, qreg1, creg0, creg1)
meas.measure(qreg0, creg0)
meas.measure(qreg1, creg1)
qc = circ + meas
backend_sim = qiskit.providers.aer.QasmSimulator()
result = execute(qc, backend_sim, seed_mapper=34342).result()
counts = result.get_counts(qc)
target = {'01 10': 1024}
backend_sim = qiskit.providers.aer.StatevectorSimulator()
result = execute(circ, backend_sim, seed_mapper=3438).result()
state = result.get_statevector(circ)
backend_sim = qiskit.providers.aer.UnitarySimulator()
result = execute(circ, backend_sim, seed_mapper=3438).result()
unitary = result.get_unitary(circ)
self.assertEqual(counts, target)
self.assertAlmostEqual(state_fidelity(basis_state('0110', 4), state), 1.0, places=7)
self.assertAlmostEqual(process_fidelity(Pauli(label='IXXI').to_matrix(), unitary),
1.0, places=7)

151
test/python/aer_provider_integration_test/test_qasm_simulator.py
View File

@ -1,151 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright 2017, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
"""Test Aer qasm simulator"""
import unittest
import numpy as np
import qiskit
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit import execute
from qiskit.test import QiskitTestCase, requires_aer_provider, Path
@requires_aer_provider
class TestAerQasmSimulator(QiskitTestCase):
"""Test the Aer qasm_simulator."""
def setUp(self):
self.seed = 88
self.backend = qiskit.providers.aer.QasmSimulator()
qasm_filename = self._get_resource_path('example.qasm', Path.QASMS)
self.circuit = QuantumCircuit.from_qasm_file(qasm_filename)
self.circuit.name = 'test'
def test_qasm_simulator_single_shot(self):
"""Test single shot run."""
shots = 1
result = execute(self.circuit, self.backend, shots=shots).result()
self.assertEqual(result.success, True)
def test_qasm_simulator(self):
"""Test data counts output for single circuit run against reference."""
result = execute(self.circuit, self.backend).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):
"""Test simulator handles conditionals correctly"""
shots = 100
qr = QuantumRegister(3, 'qr')
cr = ClassicalRegister(3, 'cr')
circuit_if_true = QuantumCircuit(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 = QuantumCircuit(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])
job = execute([circuit_if_true, circuit_if_false],
backend=self.backend, shots=shots, seed=self.seed)
result = job.result()
counts_if_true = result.get_counts(circuit_if_true)
counts_if_false = result.get_counts(circuit_if_false)
self.assertEqual(counts_if_true, {'111': 100})
self.assertEqual(counts_if_false, {'001': 100})
def test_teleport(self):
"""test teleportation as in tutorials"""
self.log.info('test_teleport')
pi = np.pi
shots = 10000
qr = QuantumRegister(3, 'qr')
cr0 = ClassicalRegister(1, 'cr0')
cr1 = ClassicalRegister(1, 'cr1')
cr2 = ClassicalRegister(1, 'cr2')
circuit = QuantumCircuit(qr, cr0, cr1, cr2, name='teleport')
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])
job = execute(circuit, backend=self.backend, shots=shots, seed=self.seed)
results = job.result()
data = results.get_counts('teleport')
alice = {
'00': data['0 0 0'] + data['1 0 0'],
'01': data['0 1 0'] + data['1 1 0'],
'10': data['0 0 1'] + data['1 0 1'],
'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'],
'1': data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']
}
self.log.info('test_teleport: circuit:')
self.log.info('test_teleport: 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)
def test_memory(self):
"""test simulator returns per-shot measurements in memory field"""
qr = QuantumRegister(4, 'qr')
cr0 = ClassicalRegister(2, 'cr0')
cr1 = ClassicalRegister(2, 'cr1')
circ = QuantumCircuit(qr, cr0, cr1)
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.x(qr[3])
circ.measure(qr[0], cr0[0])
circ.measure(qr[1], cr0[1])
circ.measure(qr[2], cr1[0])
circ.measure(qr[3], cr1[1])
shots = 50
job = execute(circ, backend=self.backend, shots=shots, memory=True)
result = job.result()
memory = result.get_memory()
self.assertEqual(len(memory), shots)
for mem in memory:
self.assertIn(mem, ['10 00', '10 11'])
if __name__ == '__main__':
unittest.main()

88
test/python/aer_provider_integration_test/test_simulator_interfaces.py
View File

@ -1,88 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
# pylint: disable=unused-import
"""Tests for checking qiskit interfaces to simulators."""
import unittest
import qiskit
import qiskit.extensions.simulator
from qiskit.quantum_info import state_fidelity
from qiskit import execute
from qiskit.test import QiskitTestCase, requires_aer_provider
@requires_aer_provider
class TestCrossSimulation(QiskitTestCase):
"""Test output consistency across simulators (from built-in and legacy simulators & IBMQ)
"""
_desired_fidelity = 0.99
def test_statevector(self):
"""statevector from a bell state"""
qr = qiskit.QuantumRegister(2)
circuit = qiskit.QuantumCircuit(qr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
sim_cpp = qiskit.providers.aer.StatevectorSimulator()
sim_py = qiskit.providers.basicaer.StatevectorSimulatorPy()
result_cpp = execute(circuit, sim_cpp).result()
result_py = execute(circuit, sim_py).result()
statevector_cpp = result_cpp.get_statevector()
statevector_py = result_py.get_statevector()
fidelity = state_fidelity(statevector_cpp, statevector_py)
self.assertGreater(
fidelity, self._desired_fidelity,
"cpp vs. py statevector has low fidelity{0:.2g}.".format(fidelity))
def test_qasm(self):
"""counts from a GHZ state"""
qr = qiskit.QuantumRegister(3)
cr = qiskit.ClassicalRegister(3)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.measure(qr, cr)
sim_cpp = qiskit.providers.aer.QasmSimulator()
sim_py = qiskit.providers.basicaer.QasmSimulatorPy()
shots = 2000
result_cpp = execute(circuit, sim_cpp, shots=shots).result()
result_py = execute(circuit, sim_py, shots=shots).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots*0.08)
def test_qasm_reset_measure(self):
"""counts from a qasm program with measure and reset in the middle"""
qr = qiskit.QuantumRegister(3)
cr = qiskit.ClassicalRegister(3)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.reset(qr[0])
circuit.cx(qr[1], qr[2])
circuit.t(qr)
circuit.measure(qr[1], cr[1])
circuit.h(qr[2])
circuit.measure(qr[2], cr[2])
sim_cpp = qiskit.providers.aer.QasmSimulator()
sim_py = qiskit.providers.basicaer.QasmSimulatorPy()
shots = 1000
result_cpp = execute(circuit, sim_cpp, shots=shots, seed=1).result()
result_py = execute(circuit, sim_py, shots=shots, seed=1).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.06)
if __name__ == '__main__':
unittest.main(verbosity=2)

92
test/python/aer_provider_integration_test/test_unitary_simulator.py
View File

@ -1,92 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright 2017, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
# pylint: disable=missing-docstring
import unittest
import numpy as np
import qiskit
from qiskit import execute
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit.test import QiskitTestCase, requires_aer_provider
@requires_aer_provider
class AerUnitarySimulatorPyTest(QiskitTestCase):
"""Test Aer unitary simulator."""
def setUp(self):
self.backend = qiskit.providers.aer.UnitarySimulator()
def test_aer_unitary_simulator_py(self):
"""Test unitary simulator."""
circuits = self._test_circuits()
job = execute(circuits, backend=self.backend)
sim_unitaries = [job.result().get_unitary(circ) for circ in circuits]
reference_unitaries = self._reference_unitaries()
norms = [np.trace(np.dot(np.transpose(np.conj(target)), actual))
for target, actual in zip(reference_unitaries, sim_unitaries)]
for norm in norms:
self.assertAlmostEqual(norm, 8)
def _test_circuits(self):
"""Return test circuits for unitary simulator"""
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
qc1 = QuantumCircuit(qr, cr)
qc2 = QuantumCircuit(qr, cr)
qc3 = QuantumCircuit(qr, cr)
qc4 = QuantumCircuit(qr, cr)
qc5 = QuantumCircuit(qr, cr)
# Test circuit 1: HxHxH
qc1.h(qr)
# Test circuit 2: IxCX
qc2.cx(qr[0], qr[1])
# Test circuit 3: CXxY
qc3.y(qr[0])
qc3.cx(qr[1], qr[2])
# Test circuit 4: (CX.I).(IxCX).(IxIxX)
qc4.h(qr[0])
qc4.cx(qr[0], qr[1])
qc4.cx(qr[1], qr[2])
# Test circuit 5 (X.Z)x(Z.Y)x(Y.X)
qc5.x(qr[0])
qc5.y(qr[0])
qc5.y(qr[1])
qc5.z(qr[1])
qc5.z(qr[2])
qc5.x(qr[2])
return [qc1, qc2, qc3, qc4, qc5]
def _reference_unitaries(self):
"""Return reference unitaries for test circuits"""
# Gate matrices
gate_h = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
gate_x = np.array([[0, 1], [1, 0]])
gate_y = np.array([[0, -1j], [1j, 0]])
gate_z = np.array([[1, 0], [0, -1]])
gate_cx = np.array([[1, 0, 0, 0],
[0, 0, 0, 1],
[0., 0, 1, 0],
[0, 1, 0, 0]])
# Unitary matrices
target_unitary1 = np.kron(np.kron(gate_h, gate_h), gate_h)
target_unitary2 = np.kron(np.eye(2), gate_cx)
target_unitary3 = np.kron(gate_cx, gate_y)
target_unitary4 = np.dot(np.kron(gate_cx, np.eye(2)),
np.dot(np.kron(np.eye(2), gate_cx),
np.kron(np.eye(4), gate_h)))
target_unitary5 = np.kron(np.kron(np.dot(gate_x, gate_z),
np.dot(gate_z, gate_y)),
np.dot(gate_y, gate_x))
return [target_unitary1, target_unitary2, target_unitary3,
target_unitary4, target_unitary5]
if __name__ == '__main__':
unittest.main()