Fix bit ordering and probabilities of samples in optimization_algorithm.py

qiskit_optimization/algorithms/optimization_algorithm.py

@@ -502,17 +502,17 @@ def _eigenvector_to_solutions(eigenvector: Union[dict, np.ndarray, StateFn],
         Raises:
             TypeError: If the type of eigenvector is not supported.
         """
+
         if isinstance(eigenvector, DictStateFn):
             eigenvector = {bitstr: val ** 2 for (bitstr, val) in eigenvector.primitive.items()}
         elif isinstance(eigenvector, StateFn):
             eigenvector = eigenvector.to_matrix()
 
         def generate_solution(bitstr, qubo, probability):
-            x = np.fromiter(list(bitstr), dtype=int)
+            x = np.fromiter(list(bitstr[::-1]), dtype=int)
             fval = qubo.objective.evaluate(x)
             return SolutionSample(x=x, fval=fval, probability=probability,
                                   status=OptimizationResultStatus.SUCCESS)
-
         solutions = []
         if isinstance(eigenvector, dict):
             all_counts = sum(eigenvector.values())
@@ -531,7 +531,7 @@ def generate_solution(bitstr, qubo, probability):
             for i, sampling_probability in enumerate(probabilities):
                 # add the i-th state if the sampling probability exceeds the threshold
                 if sampling_probability >= min_probability:
-                    bitstr = '{:b}'.format(i).rjust(num_qubits, '0')[::-1]
+                    bitstr = '{:b}'.format(i).rjust(num_qubits, '0')
                     solutions.append(generate_solution(bitstr, qubo, sampling_probability))
 
         else:

test/algorithms/test_min_eigen_optimizer.py

@@ -17,16 +17,23 @@
 
 import numpy as np
 from ddt import data, ddt
+from docplex.mp.model import Model
 
 from qiskit import BasicAer
+from qiskit.algorithms import QAOA, VQE, NumPyMinimumEigensolver
+from qiskit.algorithms.optimizers import COBYLA, SPSA
+from qiskit.circuit.library import TwoLocal
 from qiskit.exceptions import MissingOptionalLibraryError
+from qiskit.providers.aer import QasmSimulator
 from qiskit.utils import QuantumInstance, algorithm_globals
-from qiskit.algorithms import QAOA, NumPyMinimumEigensolver
-from qiskit.algorithms.optimizers import COBYLA
-from qiskit_optimization.algorithms import (CplexOptimizer, MinimumEigenOptimizer)
-from qiskit_optimization.algorithms.optimization_algorithm import OptimizationResultStatus
-from qiskit_optimization.converters import (InequalityToEquality, IntegerToBinary,
-                                            LinearEqualityToPenalty, QuadraticProgramToQubo)
+from qiskit_optimization.algorithms import (CplexOptimizer,
+                                            MinimumEigenOptimizer)
+from qiskit_optimization.algorithms.optimization_algorithm import \
+    OptimizationResultStatus
+from qiskit_optimization.converters import (InequalityToEquality,
+                                            IntegerToBinary,
+                                            LinearEqualityToPenalty,
+                                            QuadraticProgramToQubo)
 from qiskit_optimization.problems import QuadraticProgram
 
 
@@ -245,6 +252,26 @@ def test_samples(self):
         self.assertAlmostEqual(result.fval, result.samples[0].fval)
         self.assertEqual(result.status, result.samples[0].status)
 
+    def test_bit_ordering(self):
+        """Test bit ordering"""
+        mdl = Model("docplex model")
+        x = mdl.binary_var('x')
+        y = mdl.binary_var('y')
+        mdl.minimize(x-2*y)
+        seed = 1234
+        qp = QuadraticProgram()
+        qp.from_docplex(mdl)
+        backend = QasmSimulator()
+        optimizer = SPSA(maxiter=100)
+        ry = TwoLocal(2, 'ry', 'cz', reps=3, entanglement='full')
+        quantum_instance = QuantumInstance(backend=backend,
+                                           seed_simulator=seed, seed_transpiler=seed)
+        vqe_mes = VQE(ry, optimizer=optimizer, quantum_instance=quantum_instance)
+        vqe = MinimumEigenOptimizer(vqe_mes)
+        result = vqe.solve(qp)
+        self.assertEqual(result.fval, -2)
+        self.assertListEqual(result.x.tolist(), [0, 1])
+
 
 if __name__ == '__main__':
     unittest.main()