mirror of https://github.com/Qiskit/qiskit.git
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:
parent
6623e99c17
commit
018289a92b
|
@ -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"""
|
|
@ -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)
|
|
@ -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)
|
|
@ -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)
|
|
@ -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()
|
|
@ -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)
|
|
@ -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()
|
Loading…
Reference in New Issue