Skip to content

FlexQAOA

The FlexQAOA is a variant of QAOA developed by Aqarios, specifically focused on problems coming from the real world. The core issue with plain QAOA is that it requires a Quadratic Unconstrained Binary Optimization (QUBO) input format. However, real-world problems typically contain constraints, that can not be violated for a feasible solution. While constraints can be reformulated into penalty terms to form a QUBO. These penalty terms distort the energy spectrum of the optimization heavily, leading to impaired optimization performance. Additionally, in inequality-constrained cases, slack variables have to be introduced, effectively enlarging the search space.

To alleviate the issues arising with reformulation to QUBO, FlexQAOA integrates common constraints directly into the circuit architecture. Namely, it utilizes XY-mixers for the natural enforcement of one-hot constraints and Indicator Functions (IF) for effective penalization of inequality constraints.

FlexQAOA light-mode circuit diagram showing constraint-aware XY mixers and indicator functions FlexQAOA dark-mode circuit diagram showing constraint-aware XY mixers and indicator functions

Upon input of a constraint optimization problem, FlexQAOA identifies and handles the following constraint types:

  • Equality Constraints: via Quadratic Penalties.
  • Inequality Constraints:
    • via Indicator Functions.
    • via Transformation to Equality Constraints.
  • One-Hot Constraints:
    • via XY-Mixers.
    • via Transformation to Equality Constraints.
  • Setpacking Constraints:
    • via Transformation to One-Hot Constraints.
    • via slack-free Quadratic Penalty.
    • via Transformation to Inequality Constraints.

The resolution path for each constraint is automatically determined by FlexQAOA. The user can freely configure which methods shall be applied in this automatic pipeline.

So far, FlexQAOA only supports an internal simulator for execution. This simulator, however, features advanced techniques, like cost caching, reduction of state vector size and efficient evaluation of indicator functions.

Note

FlexQAOA will be extended in the future to support more types of constraints and different hardware backends. Stay tuned for updates!

Compatible Backends

Backend Default
Aqarios
AqariosGpu
AerSimulator
IBMFakeBackend
IBMQuantum

Initialization

Python
from luna_quantum.solve.parameters.algorithms.base_params.qaoa_circuit_params import LinearQAOAParams
from luna_quantum.solve.parameters.algorithms.base_params.scipy_optimizer import ScipyOptimizerParams
from luna_quantum.solve.parameters.algorithms.quantum_gate.flexqaoa.config import CustomConfig
from luna_quantum.solve.parameters.algorithms.quantum_gate.flexqaoa.flexqaoa import FlexQAOA
from luna_quantum.solve.parameters.algorithms.quantum_gate.flexqaoa.pipeline import (
    IndicatorFunctionConfig,
    InequalityToEqualityConfig,
    PenaltySetting,
    PipelineParams,
    QuadraticPenaltyConfig,
    SetpackingAsOnehotConfig,
    XYMixerConfig
)

algorithm = FlexQAOA(
    backend=None,
    shots=1024,
    reps=1,
    pipeline=PipelineParams(
        penalty=PenaltySetting(
            override=None,
            scaling=2.0
        ),
        inequality_to_equality=InequalityToEqualityConfig(
            enable=True,
            max_slack=10
        ),
        setpacking_as_onehot=SetpackingAsOnehotConfig(
            enable=True
        ),
        xy_mixer=XYMixerConfig(
            enable=True,
            trotter=1,
            method='ring'
        ),
        indicator_function=IndicatorFunctionConfig(
            enable=True,
            penalty=PenaltySetting(
                override=None,
                scaling=1.0
            ),
            method='const'
        ),
        sp_quadratic_penalty=QuadraticPenaltyConfig(
            enable=True,
            penalty=PenaltySetting(
                override=None,
                scaling=2.0
            )
        ),
        quadratic_penalty=QuadraticPenaltyConfig(
            enable=True,
            penalty=PenaltySetting(
                override=None,
                scaling=2.0
            )
        )
    ),
    optimizer=ScipyOptimizerParams(
        method='cobyla',
        tol=None,
        bounds=None,
        jac=None,
        hess=None,
        maxiter=100,
        options={}
    ),
    initial_params=LinearQAOAParams(
        delta_beta=0.5,
        delta_gamma=0.5
    ),
    param_conversion='basic',
    custom_config=CustomConfig(
        max_qubits=None,
        minimize_qubits=False,
        wstate='log',
        qft_synth='full'
    )
)

Usage

Python
from luna_quantum.algorithms import FlexQAOA

algorithm = FlexQAOA()
solve_job = algorithm.run(model, name="my-solve-job")