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)
def test_optnvo_6_key(self): """Test with 6 linear coefficients, negative quadratics, no constant.""" # Circuit parameters. try: num_value = 4 # Input. problem = QuadraticProgram() # Input. problem = QuadraticProgram() for name in ['x0', 'x1', 'x2', 'x3', 'x4', 'x5']: problem.binary_var(name) linear = [-1, -2, -1, 0, 1, 2] quadratic = {('x0', 'x3'): -1, ('x1', 'x5'): -2} problem.minimize(linear=linear, quadratic=quadratic) # Convert to dictionary format with operator/oracle. converter = QuadraticProgramToNegativeValueOracle(num_value) a_operator, _, func_dict = converter.encode(problem) self._validate_function(func_dict, problem) self._validate_operator(func_dict, len(linear), num_value, a_operator) except NameError as ex: self.skipTest(str(ex))
def test_optnvo_3_linear_2_quadratic_no_constant(self): """Test with 3 linear coefficients, 2 quadratic, and no constant.""" try: # Circuit parameters. num_value = 4 # Input. problem = QuadraticProgram() for name in ['x0', 'x1', 'x2']: problem.binary_var(name) linear = [-1, 2, -3] quadratic = {('x0', 'x2'): -2, ('x1', 'x2'): -1} problem.minimize(linear=linear, quadratic=quadratic) # Convert to dictionary format with operator/oracle. converter = QuadraticProgramToNegativeValueOracle(num_value) a_operator, _, func_dict = converter.encode(problem) self._validate_function(func_dict, problem) self._validate_operator(func_dict, len(linear), num_value, a_operator) except NameError as ex: self.skipTest(str(ex))
def test_optnvo_4_key_all_negative(self): """Test with all negative values.""" # Circuit parameters. try: num_value = 5 # Input. problem = QuadraticProgram() for name in ['x0', 'x1', 'x2']: problem.binary_var(name) linear = [-1, -2, -1] quadratic = {('x0', 'x1'): -1, ('x0', 'x2'): -2, ('x1', 'x2'): -1} problem.minimize(constant=-1, linear=linear, quadratic=quadratic) # Convert to dictionary format with operator/oracle. converter = QuadraticProgramToNegativeValueOracle(num_value) a_operator, _, func_dict = converter.encode(problem) self._validate_function(func_dict, problem) self._validate_operator(func_dict, len(linear), num_value, a_operator) except NameError as ex: self.skipTest(str(ex))
def test_samples(self): """Test samples""" SUCCESS = OptimizationResultStatus.SUCCESS # pylint: disable=invalid-name aqua_globals.random_seed = 123 quantum_instance = QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), seed_simulator=123, seed_transpiler=123, shots=1000) # test minimize op = QuadraticProgram() op.integer_var(0, 3, 'x') op.binary_var('y') op.minimize(linear={'x': 1, 'y': 2}) op.linear_constraint(linear={ 'x': 1, 'y': 1 }, sense='>=', rhs=1, name='xy') min_eigen_solver = NumPyMinimumEigensolver() min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) result = min_eigen_optimizer.solve(op) opt_sol = 1 self.assertEqual(result.fval, opt_sol) self.assertEqual(len(result.samples), 1) np.testing.assert_array_almost_equal(result.samples[0].x, [1, 0]) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertAlmostEqual(result.samples[0].probability, 1.0) self.assertEqual(result.samples[0].status, SUCCESS) self.assertEqual(len(result.raw_samples), 1) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [1, 0, 0, 0, 0]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertAlmostEqual(result.raw_samples[0].probability, 1.0) self.assertEqual(result.raw_samples[0].status, SUCCESS) qaoa = QAOA(quantum_instance=quantum_instance) min_eigen_optimizer = MinimumEigenOptimizer(qaoa) result = min_eigen_optimizer.solve(op) self.assertEqual(len(result.samples), 8) self.assertEqual(len(result.raw_samples), 32) self.assertAlmostEqual(sum(s.probability for s in result.samples), 1) self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1) self.assertAlmostEqual(min(s.fval for s in result.samples), 0) self.assertAlmostEqual( min(s.fval for s in result.samples if s.status == SUCCESS), opt_sol) self.assertAlmostEqual(min(s.fval for s in result.raw_samples), opt_sol) for sample in result.raw_samples: self.assertEqual(sample.status, SUCCESS) np.testing.assert_array_almost_equal(result.x, result.samples[0].x) self.assertAlmostEqual(result.fval, result.samples[0].fval) self.assertEqual(result.status, result.samples[0].status) # test maximize 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='<=', rhs=1, name='xy') min_eigen_solver = NumPyMinimumEigensolver() min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) result = min_eigen_optimizer.solve(op) opt_sol = 2 self.assertEqual(result.fval, opt_sol) self.assertEqual(len(result.samples), 1) np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1]) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertAlmostEqual(result.samples[0].probability, 1.0) self.assertEqual(result.samples[0].status, SUCCESS) self.assertEqual(len(result.raw_samples), 1) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [0, 0, 1, 0]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertAlmostEqual(result.raw_samples[0].probability, 1.0) self.assertEqual(result.raw_samples[0].status, SUCCESS) qaoa = QAOA(quantum_instance=quantum_instance) min_eigen_optimizer = MinimumEigenOptimizer(qaoa) result = min_eigen_optimizer.solve(op) self.assertEqual(len(result.samples), 8) self.assertEqual(len(result.raw_samples), 16) self.assertAlmostEqual(sum(s.probability for s in result.samples), 1) self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1) self.assertAlmostEqual(max(s.fval for s in result.samples), 5) self.assertAlmostEqual( max(s.fval for s in result.samples if s.status == SUCCESS), opt_sol) self.assertAlmostEqual(max(s.fval for s in result.raw_samples), opt_sol) for sample in result.raw_samples: self.assertEqual(sample.status, SUCCESS) np.testing.assert_array_almost_equal(result.x, result.samples[0].x) self.assertAlmostEqual(result.fval, result.samples[0].fval) self.assertEqual(result.status, result.samples[0].status)
quadraticCoeffDict = {} for ii in range(len(z)): for jj in range(len(z)): if ((ii >= numOfItems) and (jj >= numOfItems)): if (ii != jj): quadraticCoeffDict[(z[ii], z[jj])] = penalty else: quadraticCoeffDict[(z[ii], z[jj])] = quadraticCoeffs[ii][jj] else: quadraticCoeffDict[(z[ii], z[jj])] = quadraticCoeffs[ii][jj] #backend = BasicAer.get_backend('statevector_simulator') qubo = QuadraticProgram() for ii in range(numOfItems + backPackCap): qubo.binary_var(z[ii]) qubo.minimize(linear=linearCoeff, quadratic=quadraticCoeffDict) print(qubo.export_as_lp_string()) """qaoa_mes = QAOA(quantum_instance=BasicAer.get_backend('statevector_simulator')); qaoa = MinimumEigenOptimizer(qaoa_mes) # using QAOA qaoa_result = qaoa.solve(qubo) print(qaoa_result)""" quantumBackend = QuantumInstance(provider.get_backend('ibmq_qasm_simulator'), shots=2048, skip_qobj_validation=False) qaoa_mes = QAOA(quantum_instance=quantumBackend)