QAOA with ideal noise returns wrong result

[iuliazidaru]

Information

• Qiskit Aqua version: qiskit-aqua': '0.8.1
• Python version: 3.8.2
• Operating system: System: Darwin

What is the current behavior?

QAOA applied to the linear equation: minimize obj(x1 + x2+ x3 + ..x20) returns wrong result: 2

Steps to reproduce the problem

#%%

from qiskit.optimization import QuadraticProgram
def create_qubo_linear(num_variables):
    qubo = QuadraticProgram()
    for index in range(num_variables):
        qubo.binary_var('x' + str(index + 1))
    qubo.minimize(linear=[1] * num_variables,
                  quadratic={})
    return qubo

#%%

from qiskit.aqua import QuantumInstance
from qiskit.aqua import aqua_globals
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from qiskit.aqua.algorithms import QAOA

SEED = 10598


def solve_qubo(qubo, device, optimiser, parameter_p):
    aqua_globals.random_seed = SEED
    quantum_instance = QuantumInstance(device, seed_simulator=SEED, seed_transpiler=SEED, shots=1024)
    qaoa_mes = QAOA(quantum_instance=quantum_instance, include_custom=True, optimizer=optimiser,
                    p=parameter_p)
    qaoa = MinimumEigenOptimizer(qaoa_mes)
    qaoa_result = qaoa.solve(qubo)
    return qaoa_result

#%%

from qiskit.aqua import aqua_globals
from qiskit.aqua.components.optimizers import SLSQP
from qiskit.providers.aer import QasmSimulator
from qiskit.providers.aer.noise import NoiseModel

def test_given_qubo_linear_then_qaoa_correct_result():
    # Arrange
    nbr_variables = 20
    qubo = create_qubo_linear(nbr_variables)
    noise_model = NoiseModel()
    ##device = QasmSimulator(method='matrix_product_state')
    ##device = QasmSimulator(method='density_matrix') # insufficient memory
    device = QasmSimulator(method='automatic', noise_model=noise_model)
    #device  = Aer.get_backend('qasm_simulator')
    # Act
    result = solve_qubo(qubo, device, SLSQP(), 5)
    # Assert
    print(noise_model.is_ideal())
    print(result.fval)
    print(result.x)
    assert noise_model.is_ideal() == True
    assert result.fval == 0.0
    assert all([a == b for a, b in zip(result.x, [0] * nbr_variables)])

#%%

test_given_qubo_linear_then_qaoa_correct_result()

#%%

import qiskit
qiskit.__qiskit_version__

#%%

import sys
print(sys.version)

#%%

import platform
uname = platform.uname()
print(f"System: {uname.system}")
print(f"Node Name: {uname.node}")
print(f"Release: {uname.release}")
print(f"Version: {uname.version}")
print(f"Machine: {uname.machine}")
print(f"Processor: {uname.processor}")


#%%

What is the expected behavior?

minimum value must be 0, and the solution 00000000000000000000

Suggested solutions

I replaced the problem in QAOA example https://qiskit.org/textbook/ch-applications/qaoa.html and the result looks good.

n = 20
V = np.arange(0,n,1)
E =[]

QAOA-algorithm.ipynb.zip
QAOA-bug.ipynb.zip

[iuliazidaru]

This is related to : #1434

[manoelmarques]

In the above notebook just changing from SLSQP() to COBYLA(), I got the correct results.

[iuliazidaru]

Thank you for the hint @manoelmarques !
I have 3 tests for the same scenario in 3 projects. The test I created in qiskit-aqua worked with COBYLA.
Using

        quantum_instance = QuantumInstance(QasmSimulator(method='automatic', noise_model=NoiseModel()),
                                           seed_simulator=aqua_globals.random_seed,
                                           seed_transpiler=aqua_globals.random_seed,
                                           shots=1024)

I get a solution sample containing multiple values and value 0.

Using
BasicAer.get_backend('qasm_simulator')

In the Jupyter Notebook the solution is not found in the samples at all. It returns a huge amount of samples, but not the right one even if I choose COBYLA.

The same issue into the third project:

Any idea why?

[iuliazidaru]

@manoelmarques when I set the initial point, as you said in email, I didn't get the random result anymore and the result is correct so far.
Thank you!

[woodsp-ibm]

Closing as solved according to above discussion.