def test_particle_hole(self, atom, charge=0, spin=0, basis='sto3g', hf_method=HFMethodType.RHF):
""" particle hole test """
try:
driver = PySCFDriver(atom=atom,
unit=UnitsType.ANGSTROM,
charge=charge,
spin=spin,
basis=basis,
hf_method=hf_method)
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
config = '{}, charge={}, spin={}, basis={}, {}'.format(atom, charge,
spin, basis,
hf_method.value)
molecule = driver.run()
fer_op = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals)
ph_fer_op, ph_shift = fer_op.particle_hole_transformation([molecule.num_alpha,
molecule.num_beta])
# ph_shift should be the electronic part of the hartree fock energy
self.assertAlmostEqual(-ph_shift,
molecule.hf_energy - molecule.nuclear_repulsion_energy, msg=config)
# Energy in original fer_op should same as ph transformed one added with ph_shift
jw_op = fer_op.mapping('jordan_wigner')
result = NumPyMinimumEigensolver(jw_op).run()
ph_jw_op = ph_fer_op.mapping('jordan_wigner')
ph_result = NumPyMinimumEigensolver(ph_jw_op).run()
self.assertAlmostEqual(result.eigenvalue.real,
ph_result.eigenvalue.real - ph_shift, msg=config)
def test_tsp(self):
""" TSP test """
algo = NumPyMinimumEigensolver(self.qubit_op)
result = algo.run()
x = sample_most_likely(result.eigenstate)
order = tsp.get_tsp_solution(x)
np.testing.assert_array_equal(order, [1, 2, 0])
def test_deprecated_qft(self):
"""Test the QPE algorithm on the deprecated QFT component."""
qubit_op = self._dict['QUBIT_OP_SIMPLE']
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
warnings.filterwarnings('ignore', category=DeprecationWarning)
iqft = Standard(5)
qpe = QPE(qubit_op,
state_in,
iqft,
num_time_slices=1,
num_ancillae=5,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
shots=100,
seed_transpiler=1,
seed_simulator=1)
# run qpe
result = qpe.run(quantum_instance)
warnings.filterwarnings('always', category=DeprecationWarning)
self.assertAlmostEqual(result.eigenvalue.real,
ref_eigenval.real,
delta=2e-2)
def test_docplex_constant_and_quadratic_terms_in_object_function(self):
""" Docplex Constant and Quadratic terms in Object function test """
# Create an Ising Hamiltonian with docplex
laplacian = np.array([[-3., 1., 1., 1.], [1., -2., 1., -0.],
[1., 1., -3., 1.], [1., -0., 1., -2.]])
mdl = Model()
# pylint: disable=unsubscriptable-object
n = laplacian.shape[0]
bias = [0] * 4
x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}
couplers_func = mdl.sum(2 * laplacian[i, j] * (2 * x[i] - 1) *
(2 * x[j] - 1) for i in range(n - 1)
for j in range(i, n))
bias_func = mdl.sum(float(bias[i]) * x[i] for i in range(n))
ising_func = couplers_func + bias_func
mdl.minimize(ising_func)
qubit_op, offset = docplex.get_operator(mdl)
e_e = NumPyMinimumEigensolver(qubit_op)
result = e_e.run()
expected_result = -22
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset,
expected_result)
def test_ee(self):
""" EE test """
dummy_operator = MatrixOperator([[1]])
ee = NumPyMinimumEigensolver()
output = ee.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503)
def test_partition(self):
""" Partition test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
if x[0] != 0:
x = np.logical_not(x) * 1
np.testing.assert_array_equal(x, [0, 1, 0])
def test_set_packing(self):
""" set packing test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
ising_sol = set_packing.get_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 1, 1])
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(ising_sol), oracle)
def test_vertex_cover(self):
""" Vertex Cover test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
sol = vertex_cover.get_graph_solution(x)
np.testing.assert_array_equal(sol, [0, 0, 1])
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(sol), oracle)
def test_portfolio(self):
""" portfolio test """
algo = NumPyMinimumEigensolver(self.qubit_op)
result = algo.run()
selection = sample_most_likely(result.eigenstate)
value = portfolio.portfolio_value(selection, self.muu, self.sigma,
self.risk, self.budget, self.penalty)
np.testing.assert_array_equal(selection, [0, 1, 1, 0])
self.assertAlmostEqual(value, -0.00679917)
def test_tsp(self):
""" TSP test """
algo = NumPyMinimumEigensolver(self.qubit_op)
result = algo.run()
x = sample_most_likely(result.eigenstate)
# print(self.qubit_op.to_opflow().eval(result.eigenstate).adjoint().eval(result.eigenstate))
order = tsp.get_tsp_solution(x)
np.testing.assert_equal(tsp.tsp_value(order, self.ins.w),
tsp.tsp_value([1, 2, 0], self.ins.w))
def test_mapping(self):
""" mapping test """
qubit_op = self.bos_op.mapping('direct', threshold=1e-5)
algo = NumPyMinimumEigensolver(
qubit_op,
filter_criterion=self.bos_op.direct_mapping_filtering_criterion)
result = algo.run()
gs_energy = np.real(result['eigenvalue'])
self.assertAlmostEqual(gs_energy, self.reference_energy, places=4)
def test_graph_partition(self):
""" Graph Partition test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
# check against the oracle
ising_sol = graph_partition.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 1, 0, 1])
oracle = self._brute_force()
self.assertEqual(graph_partition.objective_value(x, self.w), oracle)
def test_clique(self):
""" Clique test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
ising_sol = clique.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 1, 1, 1])
oracle = self._brute_force()
self.assertEqual(clique.satisfy_or_not(ising_sol, self.w, self.k),
oracle)
def test_stable_set(self):
""" Stable set test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
self.assertAlmostEqual(result.eigenvalue.real, -29.5)
self.assertAlmostEqual(result.eigenvalue.real + self.offset, -25.0)
ising_sol = stable_set.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 0, 1, 1, 1])
self.assertEqual(stable_set.stable_set_value(x, self.w), (3.0, False))
def test_iqpe(self, distance):
""" iqpe test """
self.log.debug('Testing End-to-End with IQPE on H2 with '
'inter-atomic distance %s.', distance)
try:
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 {}'.format(distance),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
molecule = driver.run()
qubit_mapping = 'parity'
fer_op = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
qubit_op = fer_op.mapping(map_type=qubit_mapping, threshold=1e-10)
qubit_op = Z2Symmetries.two_qubit_reduction(qubit_op, 2)
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
reference_energy = results.eigenvalue.real
self.log.debug('The exact ground state energy is: %s', results.eigenvalue.real)
num_particles = molecule.num_alpha + molecule.num_beta
two_qubit_reduction = True
num_orbitals = qubit_op.num_qubits + (2 if two_qubit_reduction else 0)
num_time_slices = 1
num_iterations = 6
state_in = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction)
iqpe = IQPE(qubit_op, state_in, num_time_slices, num_iterations,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
backend = qiskit.BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=100)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: %s', result.top_measurement_label)
self.log.debug('top result in decimal: %s', result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final energy from QPE: %s', result.eigenvalue.real)
self.log.debug('reference energy: %s', reference_energy)
self.log.debug('ref energy (transformed): %s',
(reference_energy + result.translation) * result.stretch)
self.log.debug('ref binary str label: %s', decimal_to_binary(
(reference_energy + result.translation) * result.stretch,
max_num_digits=num_iterations + 3,
fractional_part_only=True
))
np.testing.assert_approx_equal(result.eigenvalue.real, reference_energy, significant=2)
def test_iqpe(self, qubit_op, simulator, num_time_slices, num_iterations,
use_circuits):
""" iqpe test """
self.log.debug('Testing IQPE')
qubit_op = self._dict[qubit_op]
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
if use_circuits:
state_in = QuantumCircuit(qubit_op.num_qubits)
state_in.initialize(ref_eigenvec.primitive.data, state_in.qubits)
else:
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=DeprecationWarning)
state_in = Custom(qubit_op.num_qubits,
state_vector=ref_eigenvec)
iqpe = IQPE(qubit_op,
state_in,
num_time_slices,
num_iterations,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: %s',
result.top_measurement_label)
self.log.debug('top result in decimal: %s',
result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from IQPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval.real + result.translation) *
result.stretch)
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=num_iterations + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result.eigenvalue.real,
ref_eigenval.real,
significant=2)
def test_cme(self):
""" Basic test """
algo = NumPyMinimumEigensolver(self.qubit_op,
aux_operators=self.aux_ops)
result = algo.run()
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae):
"""Test the QPE algorithm."""
self.log.debug('Testing QPE')
qubit_op = self._dict[qubit_op]
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
iqft = QFT(n_ancillae).inverse()
qpe = QPE(qubit_op,
state_in,
iqft,
num_time_slices,
n_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend,
shots=100,
seed_transpiler=1,
seed_simulator=1)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s',
result.top_measurement_label)
self.log.debug('top result in decimal: %s',
result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=n_ancillae + 3,
fractional_part_only=True))
self.assertAlmostEqual(result.eigenvalue.real,
ref_eigenval.real,
delta=2e-2)
def test_exact_cover(self):
""" Exact Cover test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
ising_sol = exact_cover.get_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 1, 1, 0])
oracle = self._brute_force()
self.assertEqual(
exact_cover.check_solution_satisfiability(ising_sol,
self.list_of_subsets),
oracle)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae):
""" QPE test """
self.log.debug('Testing QPE')
tmp_qubit_op = qubit_op.copy()
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
iqft = Standard(n_ancillae)
qpe = QPEMinimumEigensolver(qubit_op,
state_in,
iqft,
num_time_slices,
n_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s',
result.top_measurement_label)
self.log.debug('top result in decimal: %s',
result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=n_ancillae + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result.eigenvalue.real,
ref_eigenval.real,
significant=2)
self.assertEqual(tmp_qubit_op, qubit_op,
"Operator is modified after QPE.")
def _run_knapsack(values, weights, max_weight):
qubit_op, _ = knapsack.get_operator(values, weights, max_weight)
algo = NumPyMinimumEigensolver(qubit_op)
result = algo.run()
x = sample_most_likely(result.eigenstate)
solution = knapsack.get_solution(x, values)
value, weight = knapsack.knapsack_value_weight(solution, values,
weights)
return solution, value, weight
def setUp(self):
super().setUp()
try:
self.molecule = "H 0.000000 0.000000 0.735000;H 0.000000 0.000000 0.000000"
self.driver = PySCFDriver(atom=self.molecule,
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='631g')
self.qmolecule = self.driver.run()
self.core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=[])
self.qubit_op, _ = self.core.run(self.qmolecule)
z2_symmetries = Z2Symmetries.find_Z2_symmetries(self.qubit_op)
tapered_ops = z2_symmetries.taper(self.qubit_op)
smallest_eig_value = 99999999999999
smallest_idx = -1
for idx, _ in enumerate(tapered_ops):
ee = NumPyMinimumEigensolver(tapered_ops[idx])
curr_value = ee.compute_minimum_eigenvalue().eigenvalue.real
if curr_value < smallest_eig_value:
smallest_eig_value = curr_value
smallest_idx = idx
self.the_tapered_op = tapered_ops[smallest_idx]
self.reference_energy_pUCCD = -1.1434447924298028
self.reference_energy_UCCD0 = -1.1476045878481704
self.reference_energy_UCCD0full = -1.1515491334334347
# reference energy of UCCSD/VQE with tapering everywhere
self.reference_energy_UCCSD = -1.1516142309717594
# reference energy of UCCSD/VQE when no tapering on excitations is used
self.reference_energy_UCCSD_no_tap_exc = -1.1516142309717594
# excitations for succ
self.reference_singlet_double_excitations = [[0, 1, 4, 5],
[0, 1, 4, 6],
[0, 1, 4, 7],
[0, 2, 4, 6],
[0, 2, 4, 7],
[0, 3, 4, 7]]
# groups for succ_full
self.reference_singlet_groups = [[[0, 1, 4, 5]],
[[0, 1, 4, 6], [0, 2, 4, 5]],
[[0, 1, 4, 7], [0, 3, 4, 5]],
[[0, 2, 4, 6]],
[[0, 2, 4, 7], [0, 3, 4, 6]],
[[0, 3, 4, 7]]]
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
def test_no_symmetry(self):
""" No symmetry reduction """
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=False,
orbital_reduction=None,
z2symmetry_reduction=None)
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 12)
npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)
result = core.process_algorithm_result(npme.compute_minimum_eigenvalue())
self._validate_result(result, False)
def test_given_symmetry(self):
""" Supplied symmetry reduction """
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=False,
orbital_reduction=None,
z2symmetry_reduction=[1, 1, 1, 1])
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 8)
npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)
result = core.process_algorithm_result(npme.compute_minimum_eigenvalue())
self._validate_result(result)
self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [1, 1, 1, 1])
def test_auto_ph_freeze_core_parity_2(self):
""" Auto symmetry reduction, with freeze core, parity and two q reduction """
core = Hamiltonian(transformation=TransformationType.PARTICLE_HOLE,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=None,
z2symmetry_reduction='auto')
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 6)
npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)
result = core.process_algorithm_result(npme.compute_minimum_eigenvalue())
self._validate_result(result)
self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [1, 1])
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae, use_circuit_library):
""" QPE test """
self.log.debug('Testing QPE')
qubit_op = self._dict[qubit_op]
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
if use_circuit_library:
iqft = QFT(n_ancillae).inverse()
else:
# ignore deprecation warnings from QFTs
warnings.filterwarnings(action="ignore", category=DeprecationWarning)
iqft = Standard(n_ancillae)
qpe = QPE(qubit_op, state_in, iqft, num_time_slices, n_ancillae,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s', result.top_measurement_label)
self.log.debug('top result in decimal: %s', result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug('reference binary str label: %s', decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=n_ancillae + 3,
fractional_part_only=True
))
np.testing.assert_approx_equal(result.eigenvalue.real, ref_eigenval.real, significant=2)
if not use_circuit_library:
warnings.filterwarnings(action="always", category=DeprecationWarning)
def test_cme_filter_empty(self):
""" Test with filter always returning False """
# define filter criterion
# pylint: disable=unused-argument
def criterion(x, v, a_v):
return False
algo = NumPyMinimumEigensolver(self.qubit_op,
aux_operators=self.aux_ops,
filter_criterion=criterion)
result = algo.run()
self.assertEqual(result.eigenvalue, None)
self.assertEqual(result.eigenstate, None)
self.assertEqual(result.aux_operator_eigenvalues, None)
def test_admm_maximization(self):
"""Tests a simple maximization problem using ADMM optimizer"""
try:
mdl = Model('simple-max')
c = mdl.continuous_var(lb=0, ub=10, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
# qubo_optimizer = CplexOptimizer()
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([10, 0], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(10, solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
except NameError as ex:
self.skipTest(str(ex))
def test_recursive_min_eigen_optimizer(self):
"""Test the recursive minimum eigen optimizer."""
try:
filename = 'op_ip1.lp'
# get minimum eigen solver
min_eigen_solver = NumPyMinimumEigensolver()
# construct minimum eigen optimizer
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=4)
# load optimization problem
problem = QuadraticProgram()
problem.read_from_lp_file(self.resource_path + filename)
# solve problem with cplex
cplex = CplexOptimizer()
cplex_result = cplex.solve(problem)
# solve problem
result = recursive_min_eigen_optimizer.solve(problem)
# analyze results
self.assertAlmostEqual(cplex_result.fval, result.fval)
except RuntimeError as ex:
msg = str(ex)
if 'CPLEX' in msg:
self.skipTest(msg)
else:
self.fail(msg)
def test_converter_list(self):
"""Test converter list"""
op = QuadraticProgram()
op.integer_var(0, 3, "x")
op.binary_var('y')
op.maximize(linear={'x': 1, 'y': 2})
op.linear_constraint(linear={
'x': 1,
'y': 1
},
sense='LE',
rhs=3,
name='xy_leq')
min_eigen_solver = NumPyMinimumEigensolver()
# a single converter
qp2qubo = QuadraticProgramToQubo()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver,
converters=qp2qubo)
result = min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
# a list of converters
ineq2eq = InequalityToEquality()
int2bin = IntegerToBinary()
penalize = LinearEqualityToPenalty()
converters = [ineq2eq, int2bin, penalize]
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver,
converters=converters)
self.assertEqual(result.fval, 4)
with self.assertRaises(TypeError):
invalid = [qp2qubo, "invalid converter"]
MinimumEigenOptimizer(min_eigen_solver, converters=invalid)
