Source code for qrisp.qaoa.problems.maxCut

"""
********************************************************************************
* Copyright (c) 2025 the Qrisp authors
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the Eclipse
* Public License, v. 2.0 are satisfied: GNU General Public License, version 2
* with the GNU Classpath Exception which is
* available at https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
********************************************************************************
"""

from qrisp import *
import numpy as np
import jax.numpy as jnp

from numba import njit, prange
from jax import jit, vmap


def maxcut_obj(x, G):
    return maxcut_obj_jitted(int(x[::-1], 2), list(G.edges()))


@njit(cache=True)
def maxcut_obj_jitted(x, edge_list):
    cut = 0
    for i, j in edge_list:
        # the edge is cut
        if ((x >> i) ^ (x >> j)) & 1:
            # if x[i] != x[j]:
            cut -= 1
    return cut


@njit(parallel=True, cache=True)
def maxcut_energy(outcome_array, count_array, edge_list):

    res_array = np.zeros(len(outcome_array))
    for i in prange(len(outcome_array)):
        res_array[i] = maxcut_obj_jitted(outcome_array[i], edge_list) * count_array[i]

    return np.sum(res_array)


[docs] def create_maxcut_cl_cost_function(G): """ Creates the classical cost function for an instance of the maximum cut problem for a given graph ``G``. Parameters ---------- G : nx.Graph The Graph for the problem instance. Returns ------- cl_cost_function : function The classical cost function for the problem instance, which takes a dictionary of measurement results as input. """ def cl_cost_function(counts): edge_list = np.array(list(G.edges()), dtype=np.uint32) counts_keys = list(counts.keys()) int_list = [] if not isinstance(counts_keys[0], str): for c_array in counts_keys: integer = int("".join([c for c in c_array])[::-1], 2) int_list.append(integer) else: for c_str in counts_keys: integer = int(c_str[::-1], 2) int_list.append(integer) counts_array = np.array(list(counts.values())) outcome_array = np.array(int_list, dtype=np.uint32) return maxcut_energy(outcome_array, counts_array, edge_list) return cl_cost_function
@jit def extract_boolean_digit(integer, digit): return (integer >> digit) & 1 def create_cut_computer(G): edge_list = jnp.array(G.edges()) @jit def cut_computer(x): x_uint = jnp.uint32(x) bools = extract_boolean_digit(x_uint, edge_list[:, 0]) != extract_boolean_digit( x_uint, edge_list[:, 1] ) cut = jnp.sum(bools) # Count the number of edges crossing the cut return -cut return cut_computer def create_maxcut_sample_array_post_processor(G): cut_computer = create_cut_computer(G) def post_processor(sample_array): cut_values = vmap(cut_computer)( sample_array ) # Use vmap for automatic vectorization average_cut = jnp.mean(cut_values) return average_cut return post_processor
[docs] def create_maxcut_cost_operator(G): r""" Creates the cost operator for an instance of the maximum cut problem for a given graph ``G``. Parameters ---------- G : nx.Graph The Graph for the problem instance. Returns ------- cost_operator : function A function receiving a :ref:`QuantumVariable` and a real parameter $\gamma$. This function performs the application of the cost operator. """ def maxcut_cost_operator(qv, gamma): if not check_for_tracing_mode(): if len(G) != len(qv): raise Exception( f"Tried to call MaxCut cost Operator for graph of size {len(G)} on argument of invalid size {len(qv)}" ) for pair in list(G.edges()): rzz(2 * gamma, qv[pair[0]], qv[pair[1]]) # cx(qv[pair[0]], qv[pair[1]]) # rz(2 * gamma, qv[pair[1]]) # cx(qv[pair[0]], qv[pair[1]]) # barrier(qv) return maxcut_cost_operator
[docs] def maxcut_problem(G): """ Creates a QAOA problem instance with appropriate phase separator, mixer, and classical cost function. Parameters ---------- G : nx.Graph The graph for the problem instance. Returns ------- :ref:`QAOAProblem` A QAOA problem instance for MaxCut for a given graph ``G``. """ from qrisp.qaoa import QAOAProblem, RX_mixer return QAOAProblem( create_maxcut_cost_operator(G), RX_mixer, create_maxcut_cl_cost_function(G) )