def setUp(self):
super().setUp()
seed = 0
aqua_globals.random_seed = seed
self.num_qubits = 3
paulis = [
Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ',
repeat=self.num_qubits)
]
weights = aqua_globals.random.random(len(paulis))
self.qubit_op = WeightedPauliOperator.from_list(paulis, weights)
self.var_form = EfficientSU2(self.qubit_op.num_qubits, reps=1)
qasm_simulator = BasicAer.get_backend('qasm_simulator')
self.quantum_instance_qasm = QuantumInstance(qasm_simulator,
shots=65536,
seed_simulator=seed,
seed_transpiler=seed)
statevector_simulator = BasicAer.get_backend('statevector_simulator')
self.quantum_instance_statevector = \
QuantumInstance(statevector_simulator, shots=1,
seed_simulator=seed, seed_transpiler=seed)
def test_ryrz_circuit(self):
"""Test an EfficientSU2 circuit."""
num_qubits = 3
reps = 2
entanglement = 'circular'
parameters = ParameterVector('theta', 2 * num_qubits * (reps + 1))
param_iter = iter(parameters)
expected = QuantumCircuit(3)
for _ in range(reps):
for i in range(num_qubits):
expected.ry(next(param_iter), i)
for i in range(num_qubits):
expected.rz(next(param_iter), i)
expected.cx(2, 0)
expected.cx(0, 1)
expected.cx(1, 2)
for i in range(num_qubits):
expected.ry(next(param_iter), i)
for i in range(num_qubits):
expected.rz(next(param_iter), i)
library = EfficientSU2(num_qubits, reps=reps, entanglement=entanglement).assign_parameters(
parameters
)
self.assertCircuitEqual(library, expected)
def _variational(size, id, measure=True):
name = 'Variational' + str(size) + '_' + str(id)
_var_circ = EfficientSU2(num_qubits=size, entanglement="linear")
_var_circ.name = name
if measure:
_var_circ.measure_all()
return _var_circ
def vqe_create_solver(num_particles, num_orbitals, qubit_mapping,
two_qubit_reduction, z2_symmetries,
initial_point = system.opt_amplitudes,
noise = noise):
initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping,
two_qubit_reduction, z2_symmetries.sq_list)
var_form = UCCSD(num_orbitals=num_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=z2_symmetries)
if noise:
var_form = EfficientSU2(num_qubits = no_qubits, entanglement="linear")
else:
var_form = UCCSD(num_orbitals=num_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=z2_symmetries)
vqe = VQE(var_form=var_form, optimizer=SLSQP(maxiter=500),
include_custom=True, initial_point = initial_point)
vqe.quantum_instance = backend
return vqe
def __init__(self,
N,
method,
rand_generator,
numberoflayers=2,
qiskit_qc=None):
"""
method can be either efficient_SU2, or random_numbers, or...
"""
self.N = N
self.method = method #Can be either random numbers or...
self.rand_generator = rand_generator
#self.numpyseed = rand_generator
self.numberoflayers = numberoflayers
self.qiskit_circuit = None
self.statevector_evaluatedbefore = False
self.statevector = None
if self.method == "own_qiskit_circuit" and qiskit_qc == None:
raise (RuntimeError(
"You need to include a qiskit circuit to use this method"))
if self.method == "efficient_SU2":
qc = EfficientSU2(self.N,
reps=self.numberoflayers,
entanglement="full",
skip_final_rotation_layer=False)
num_params = qc.num_parameters
#np.random.seed(self.numpyseed)
#initial_state_params = np.random.rand(num_params)
initial_state_params = self.rand_generator.random(num_params)
for index in range(num_params):
qc = qc.bind_parameters({
qc.ordered_parameters[index]:
initial_state_params[index]
})
self.qiskit_circuit = qc
if self.method == "own_qiskit_circuit":
self.qiskit_circuit = deepcopy(qiskit_qc)
if self.method == "TFI_hardware_inspired": #Creates layers of single X rotations, followed by ZZ entangling gate rotations
qc = QuantumCircuit(self.N)
#np.random.seed(self.numpyseed)
#self.startingrandomnumbers = np.random.rand(self.numberoflayers*(self.N + self.N-1)+self.N)
self.startingrandomnumbers = self.rand_generator.random(
self.numberoflayers * (self.N + self.N - 1) + self.N)
counter = 0
for i in range(self.numberoflayers):
for j in range(self.N):
qc.rx(self.startingrandomnumbers[counter], j)
counter = counter + 1
for k in range(self.N - 1):
qc.rzz(self.startingrandomnumbers[counter], k, k + 1)
counter = counter + 1
for j in range(self.N):
qc.rx(self.startingrandomnumbers[counter], j)
counter = counter + 1
self.qiskit_circuit = qc
def variational_circuit():
# BUILD VARIATIONAL CIRCUIT HERE - START
# import required qiskit libraries if additional libraries are required
# build the variational circuit
#var_circuit = EfficientSU2(num_qubits=3, su2_gates= ['rx', 'ry'], entanglement='circular', reps=3)
var_circuit = EfficientSU2(num_qubits=5, su2_gates= ['rx', 'ry'], entanglement='circular', reps=3)
# BUILD VARIATIONAL CIRCUIT HERE - END
"""
# return the variational circuit which is either a VaritionalForm or QuantumCircuit object
from qiskit.circuit import QuantumCircuit, ParameterVector
num_qubits = 4
reps = 2 # number of times you'd want to repeat the circuit
reps_2 = 2
x = ParameterVector('x', length=reps*(5*num_qubits-1)) # creating a list of Parameters
qc = QuantumCircuit(num_qubits)
# defining our parametric form
for k in range(reps):
for i in range(num_qubits):
qc.rx(x[2*i+k*(5*num_qubits-1)],i)
qc.ry(x[2*i+1+k*(5*num_qubits-1)],i)
for i in range(num_qubits-1):
qc.cx(i,i+1)
for i in range(num_qubits-1):
qc.rz(2.356194490192345, i)
qc.rx(1.5707963267948966, i)
qc.rz(-2.356194490192345, i+1)
qc.rx(1.5707963267948966, i+1)
qc.cz(i, i+1)
qc.rz(-1.5707963267948966, i)
qc.rx(1.5707963267948966, i)
qc.rz(x[i+2*(num_qubits)+k*(5*num_qubits-1)], i)
qc.rx(-1.5707963267948966, i)
qc.rz(1.5707963267948966, i+1)
qc.rx(1.5707963267948966, i+1)
qc.rz(x[i+2*(num_qubits)+k*(5*num_qubits-1)], i+1)
qc.rx(-1.5707963267948966, i+1)
qc.cz(i, i+1)
qc.rz(-1.5707963267948966, i)
qc.rx(1.5707963267948966, i)
qc.rz(0.7853981633974483, i)
qc.rz(-1.5707963267948966, i+1)
qc.rx(-1.5707963267948966, i+1)
qc.rz(2.356194490192345, i+1)
for i in range(num_qubits):
qc.rx(x[2*i+3*num_qubits-1+k*(5*num_qubits-1)],i)
qc.ry(x[2*i+1+3*num_qubits-1+k*(5*num_qubits-1)],i)
"""
#custom_circ.draw()
return var_circuit
def test_circuit_input(self):
"""Test running the VQE on a plain QuantumCircuit object."""
wavefunction = QuantumCircuit(2).compose(EfficientSU2(2))
optimizer = SLSQP(maxiter=50)
vqe = VQE(self.h2_op, wavefunction, optimizer=optimizer)
result = vqe.run(self.statevector_simulator)
self.assertAlmostEqual(result.eigenvalue.real,
self.h2_energy,
places=5)
def setUp(self):
super().setUp()
self.sv_backend = BasicAer.get_backend("statevector_simulator")
self.qasm_backend = BasicAer.get_backend("qasm_simulator")
self.expectation = MatrixExpectation()
self.hamiltonian = 0.1 * (Z ^ Z) + (I ^ X) + (X ^ I)
self.observable = Z ^ Z
self.ansatz = EfficientSU2(2, reps=1)
self.initial_parameters = np.zeros(self.ansatz.num_parameters)
def test_construct_circuit(self, expectation, num_circuits):
"""Test construct circuits returns QuantumCircuits and the right number of them."""
wavefunction = EfficientSU2(2, reps=1)
vqe = VQE(self.h2_op, wavefunction, expectation=expectation)
params = [0] * wavefunction.num_parameters
circuits = vqe.construct_circuit(params)
self.assertEqual(len(circuits), num_circuits)
for circuit in circuits:
self.assertIsInstance(circuit, QuantumCircuit)
def test_ryrz_blocks(self):
"""Test that the EfficientSU2 circuit is instantiated correctly."""
two = EfficientSU2(3)
with self.subTest(msg='test rotation gate'):
self.assertEqual(len(two.rotation_blocks), 2)
self.assertIsInstance(two.rotation_blocks[0].data[0][0], RYGate)
self.assertIsInstance(two.rotation_blocks[1].data[0][0], RZGate)
with self.subTest(msg='test parameter bounds'):
expected = [(-np.pi, np.pi)] * two.num_parameters
np.testing.assert_almost_equal(two.parameter_bounds, expected)
def run_efficientsu2():
# define the circuit to run the benchmark on
circuit = EfficientSU2(4)
# define the stats for the benchmark
benchmark = Benchmark(2**np.arange(2, 6), H, 12)
# run
benchmark.run_benchmark(circuit)
# and plot
benchmark.plot(show=True)
def variational_circuit():
# BUILD VARIATIONAL CIRCUIT HERE - START
# import required qiskit libraries if additional libraries are required
# build the variational circuit
var_circuit = EfficientSU2(3, entanglement='full', reps=3)
# BUILD VARIATIONAL CIRCUIT HERE - END
# return the variational circuit which is either a VaritionalForm or QuantumCircuit object
return var_circuit
def test_eval_observables(self, observables: ListOrDict[OperatorBase]):
"""Tests evaluator of auxiliary operators for algorithms."""
ansatz = EfficientSU2(2)
parameters = np.array(
[
1.2, 4.2, 1.4, 2.0, 1.2, 4.2, 1.4, 2.0, 1.2, 4.2, 1.4, 2.0,
1.2, 4.2, 1.4, 2.0
],
dtype=float,
)
bound_ansatz = ansatz.bind_parameters(parameters)
expected_result = self.get_exact_expectation(bound_ansatz, observables)
for backend_name in self.backend_names:
shots = 4096 if backend_name == "qasm_simulator" else 1
decimal = (1 if backend_name == "qasm_simulator" else 6
) # to accommodate for qasm being imperfect
with self.subTest(msg=f"Test {backend_name} backend."):
backend = BasicAer.get_backend(backend_name)
quantum_instance = QuantumInstance(
backend=backend,
shots=shots,
seed_simulator=self.seed,
seed_transpiler=self.seed,
)
expectation = ExpectationFactory.build(
operator=self.h2_op,
backend=quantum_instance,
)
with self.subTest(msg="Test QuantumCircuit."):
self._run_test(
expected_result,
bound_ansatz,
decimal,
expectation,
observables,
quantum_instance,
)
with self.subTest(msg="Test Statevector."):
statevector = Statevector(bound_ansatz)
self._run_test(
expected_result,
statevector,
decimal,
expectation,
observables,
quantum_instance,
)
def test_stable_set_vqe(self):
""" VQE Stable set test """
result = VQE(self.qubit_op, EfficientSU2(
reps=3, entanglement='linear'), L_BFGS_B(maxfun=6000)).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result.eigenstate)
self.assertAlmostEqual(result.eigenvalue, -39.5)
self.assertAlmostEqual(result.eigenvalue + self.offset, -38.0)
ising_sol = stable_set.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 0, 1, 1])
self.assertEqual(stable_set.stable_set_value(x, self.w), (4.0, False))
def test_construct_circuit(self, expectation, num_circuits):
"""Test construct circuits returns QuantumCircuits and the right number of them."""
try:
wavefunction = EfficientSU2(2, reps=1)
vqe = VQE(self.h2_op, wavefunction, expectation=expectation)
params = [0] * wavefunction.num_parameters
circuits = vqe.construct_circuit(params)
self.assertEqual(len(circuits), num_circuits)
for circuit in circuits:
self.assertIsInstance(circuit, QuantumCircuit)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
return
def variational_circuit():
# BUILD VARIATIONAL CIRCUIT HERE - START
# import required qiskit libraries if additional libraries are required
feature_dim = 3
classifier_circ = EfficientSU2(feature_dim,entanglement='linear', reps=10)
# classifier_circ.draw()
# build the variational circuit
var_circuit = classifier_circ
# BUILD VARIATIONAL CIRCUIT HERE - END
# return the variational circuit which is either a VaritionalForm or QuantumCircuit object
return var_circuit
def variational_circuit():
# BUILD VARIATIONAL CIRCUIT HERE - START
# import required qiskit libraries if additional libraries are required
# build the variational circuit
var_circuit = EfficientSU2(3, entanglement='full', reps=5)#, su2_gates = ['rz', 'y', 'x'])
#RealAmplitudes(num_qubits = 3, entanglement = 'full', reps = 4)
#
# BUILD VARIATIONAL CIRCUIT HERE - END
# return the variational circuit which is either a VaritionalForm or QuantumCircuit object
return var_circuit
def test_coder_qc(self):
"""Test runtime encoder and decoder for circuits."""
bell = ReferenceCircuits.bell()
unbound = EfficientSU2(num_qubits=4, reps=1, entanglement='linear')
subtests = (bell, unbound, [bell, unbound])
for circ in subtests:
with self.subTest(circ=circ):
encoded = json.dumps(circ, cls=RuntimeEncoder)
self.assertIsInstance(encoded, str)
decoded = json.loads(encoded, cls=RuntimeDecoder)
if not isinstance(circ, list):
decoded = [decoded]
self.assertTrue(
all(isinstance(item, QuantumCircuit) for item in decoded))
def test_usage_in_vqc(self):
"""Test using the circuit the a single VQC iteration works."""
feature_dim = 4
_, training_input, test_input, _ = wine(training_size=1,
test_size=1,
n=feature_dim,
plot_data=False)
feature_map = RawFeatureVector(feature_dimension=feature_dim)
vqc = VQC(COBYLA(maxiter=1), feature_map,
EfficientSU2(feature_map.num_qubits, reps=1), training_input,
test_input)
backend = Aer.get_backend('qasm_simulator')
result = vqc.run(backend)
self.assertTrue(result['eval_count'] > 0)
def test_exact_cover_vqe(self):
""" Exact Cover VQE test """
algorithm_globals.random_seed = 10598
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed)
result = VQE(EfficientSU2(self.qubit_op.num_qubits, reps=5),
COBYLA(),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
ising_sol = exact_cover.get_solution(x)
oracle = self._brute_force()
self.assertEqual(exact_cover.check_solution_satisfiability(ising_sol, self.list_of_subsets),
oracle)
def test_gradient_supported(self):
"""Test the gradient support is correctly determined."""
# gradient supported here
wrapped = EfficientSU2(2) # a circuit wrapped into a big instruction
plain = wrapped.decompose(
) # a plain circuit with already supported instructions
# gradients not supported on the following circuits
x = Parameter("x")
duplicated = QuantumCircuit(2)
duplicated.rx(x, 0)
duplicated.rx(x, 1)
needs_chainrule = QuantumCircuit(2)
needs_chainrule.rx(2 * x, 0)
custom_gate = WhatAmI(x)
unsupported = QuantumCircuit(2)
unsupported.append(custom_gate, [0, 1])
tests = [
(wrapped, True), # tuple: (circuit, gradient support)
(plain, True),
(duplicated, False),
(needs_chainrule, False),
(unsupported, False),
]
# used to store the info if a gradient callable is passed into the
# optimizer of not
info = {"has_gradient": None}
optimizer = partial(gradient_supplied, info=info)
pvqd = PVQD(
ansatz=None,
initial_parameters=np.array([]),
optimizer=optimizer,
quantum_instance=self.sv_backend,
expectation=self.expectation,
)
problem = EvolutionProblem(self.hamiltonian, time=0.01)
for circuit, expected_support in tests:
with self.subTest(circuit=circuit,
expected_support=expected_support):
pvqd.ansatz = circuit
pvqd.initial_parameters = np.zeros(circuit.num_parameters)
_ = pvqd.evolve(problem)
self.assertEqual(info["has_gradient"], expected_support)
def test_measurement_error_mitigation_with_vqe(self):
""" measurement error mitigation test with vqe """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
h2_hamiltonian = -1.052373245772859 * (I ^ I) \
+ 0.39793742484318045 * (I ^ Z) \
- 0.39793742484318045 * (Z ^ I) \
- 0.01128010425623538 * (Z ^ Z) \
+ 0.18093119978423156 * (X ^ X)
optimizer = SPSA(maxiter=200)
var_form = EfficientSU2(2, reps=1)
vqe = VQE(
var_form=var_form,
operator=h2_hamiltonian,
quantum_instance=quantum_instance,
optimizer=optimizer,
)
result = vqe.compute_minimum_eigenvalue()
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, places=2)
def test_vertex_cover_vqe(self):
""" Vertex Cover VQE test """
aqua_globals.random_seed = self.seed
result = VQE(self.qubit_op,
EfficientSU2(reps=3),
SPSA(max_trials=200),
max_evals_grouped=2).run(
QuantumInstance(
BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result.eigenstate)
sol = vertex_cover.get_graph_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(sol), oracle)
def test_vertex_cover_vqe(self):
""" Vertex Cover VQE test """
algorithm_globals.random_seed = self.seed
q_i = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed)
result = VQE(EfficientSU2(reps=3),
SPSA(maxiter=200),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(
operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
sol = vertex_cover.get_graph_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(sol), oracle)
def vqe_create_solver(num_particles, num_orbitals, qubit_mapping,
two_qubit_reduction, z2_symmetries):
initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping,
two_qubit_reduction, z2_symmetries.sq_list)
# var_form = UCCSD(num_orbitals=num_orbitals,
# num_particles=num_particles,
# initial_state=initial_state,
# qubit_mapping=qubit_mapping,
# two_qubit_reduction=two_qubit_reduction,
# z2_symmetries=z2_symmetries)
var_form = EfficientSU2(num_qubits=no_qubits, entanglement="linear")
vqe = VQE(var_form=var_form,
optimizer=SPSA(maxiter=500),
include_custom=True)
vqe.quantum_instance = quantum_instance
return vqe
def run_vqe(
self,
backend=Aer.get_backend("statevector_simulator"),
var_form=None,
optimizer=None,
reps=5,
mode="min_val",
):
"""Run variational quantum eigensolver."""
# N=int(np.ceil(np.log2(len(self.mat))))
# hk = np.zeros((2**N,2**N),dtype='complex')
# hk[:self.mat.shape[0], :self.mat.shape[1]] = self.mat
N = self.n_qubits()
if mode == "max_val":
Hamil_mat = aqua.operators.MatrixOperator(-1 * self.mat)
# Hamil_mat = MatrixOperator(-1 * self.mat)
else:
Hamil_mat = aqua.operators.MatrixOperator(self.mat)
# Hamil_mat = MatrixOperator(self.mat)
Hamil_qop = aqua.operators.op_converter.to_weighted_pauli_operator(
Hamil_mat)
if var_form is None:
from qiskit.circuit.library import EfficientSU2
var_form = EfficientSU2(N, reps=reps)
if optimizer is None:
vqe = aqua.algorithms.VQE(Hamil_qop, var_form)
# vqe = VQE(Hamil_qop, var_form)
else:
vqe = aqua.algorithms.VQE(Hamil_qop, var_form, optimizer)
# vqe = VQE(Hamil_qop, var_form, optimizer)
vqe_result = vqe.run(backend)
en = np.real(vqe_result["eigenvalue"])
# params=vqe.optimal_params
# circuit=vqe.construct_circuit(params)
if mode == "max_val":
en = -1 * en
# states = np.sort(
# np.real(
# vqe.expectation.convert(
# StateFn(vqe.operator, is_measurement=True)
# ).to_matrix()
# )
# )
return en, vqe_result, vqe
def test_measurement_error_mitigation_with_vqe(self):
"""measurement error mitigation test with vqe"""
try:
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex:
self.skipTest(
"Package doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend("aer_simulator")
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
)
h2_hamiltonian = (-1.052373245772859 * (I ^ I) + 0.39793742484318045 *
(I ^ Z) - 0.39793742484318045 * (Z ^ I) -
0.01128010425623538 * (Z ^ Z) + 0.18093119978423156 *
(X ^ X))
optimizer = SPSA(maxiter=200)
ansatz = EfficientSU2(2, reps=1)
vqe = VQE(ansatz=ansatz,
optimizer=optimizer,
quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(operator=h2_hamiltonian)
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, delta=0.05)
def test_measurement_error_mitigation_with_vqe(self, config):
"""measurement error mitigation test with vqe"""
if _ERROR_MITIGATION_IMPORT_ERROR is not None:
self.skipTest(
f"Package doesn't appear to be installed. Error: '{_ERROR_MITIGATION_IMPORT_ERROR}'"
)
return
fitter_str, mit_pattern = config
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
fitter_cls = (CompleteMeasFitter if fitter_str == "CompleteMeasFitter"
else TensoredMeasFitter)
backend = Aer.get_backend("aer_simulator")
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=fitter_cls,
mit_pattern=mit_pattern,
)
h2_hamiltonian = (-1.052373245772859 * (I ^ I) + 0.39793742484318045 *
(I ^ Z) - 0.39793742484318045 * (Z ^ I) -
0.01128010425623538 * (Z ^ Z) + 0.18093119978423156 *
(X ^ X))
optimizer = SPSA(maxiter=200)
ansatz = EfficientSU2(2, reps=1)
vqe = VQE(ansatz=ansatz,
optimizer=optimizer,
quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(operator=h2_hamiltonian)
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, delta=0.05)
def test_ryrz_circuit(self):
"""Test an EfficientSU2 circuit."""
num_qubits = 3
reps = 2
entanglement = "circular"
parameters = ParameterVector("theta", 2 * num_qubits * (reps + 1))
param_iter = iter(parameters)
# ┌──────────┐┌──────────┐┌───┐ ┌──────────┐┌──────────┐ »
# q_0: ┤ Ry(θ[0]) ├┤ Rz(θ[3]) ├┤ X ├──■──┤ Ry(θ[6]) ├┤ Rz(θ[9]) ├─────────────»
# ├──────────┤├──────────┤└─┬─┘┌─┴─┐└──────────┘├──────────┤┌───────────┐»
# q_1: ┤ Ry(θ[1]) ├┤ Rz(θ[4]) ├──┼──┤ X ├─────■──────┤ Ry(θ[7]) ├┤ Rz(θ[10]) ├»
# ├──────────┤├──────────┤ │ └───┘ ┌─┴─┐ ├──────────┤├───────────┤»
# q_2: ┤ Ry(θ[2]) ├┤ Rz(θ[5]) ├──■──────────┤ X ├────┤ Ry(θ[8]) ├┤ Rz(θ[11]) ├»
# └──────────┘└──────────┘ └───┘ └──────────┘└───────────┘»
# « ┌───┐ ┌───────────┐┌───────────┐
# «q_0: ┤ X ├──■──┤ Ry(θ[12]) ├┤ Rz(θ[15]) ├─────────────
# « └─┬─┘┌─┴─┐└───────────┘├───────────┤┌───────────┐
# «q_1: ──┼──┤ X ├──────■──────┤ Ry(θ[13]) ├┤ Rz(θ[16]) ├
# « │ └───┘ ┌─┴─┐ ├───────────┤├───────────┤
# «q_2: ──■───────────┤ X ├────┤ Ry(θ[14]) ├┤ Rz(θ[17]) ├
# « └───┘ └───────────┘└───────────┘
expected = QuantumCircuit(3)
for _ in range(reps):
for i in range(num_qubits):
expected.ry(next(param_iter), i)
for i in range(num_qubits):
expected.rz(next(param_iter), i)
expected.cx(2, 0)
expected.cx(0, 1)
expected.cx(1, 2)
for i in range(num_qubits):
expected.ry(next(param_iter), i)
for i in range(num_qubits):
expected.rz(next(param_iter), i)
library = EfficientSU2(
num_qubits, reps=reps,
entanglement=entanglement).assign_parameters(parameters)
self.assertCircuitEqual(library, expected)
def setUp(self):
super().setUp()
self.sv_backend = BasicAer.get_backend("statevector_simulator")
self.expectation = MatrixExpectation()
self.hamiltonian = 0.1 * (Z ^ Z) + (I ^ X) + (X ^ I)
self.ansatz = EfficientSU2(2, reps=1)
