The **Max-Cut** problem is one of the best know and most studied problems of Combinatorial Optimization. It can be described as follows.

A weighted undirected graph * G* = (

*) is given, where*

**V, E, w***is a set of nodes and*

**V***is a set of edges, i.e., of unordered pairs of nodes. An edge of E is denoted by the two nodes of the corresponding pair, thus, e.g.,*

**E****is the edge having**

*ij***and**

*i***as end-nodes. Every edge**

*j**of*

**ij***is assigned a weight, i.e., a real number*

**E***.*

**w**_{ij} For any partition (**W, **** V\W**) of the node-set V, let us consider the edges of E having the two end-nodes in different sets of the partition. This subset of edges is called a

**cut**. Therefore, we have a cut for every partition of

*. If*

**V***is empty or if*

**W***, the partition is made of a single set and the corresponding cut is the empty set. If V has n nodes, the total number of partitions (including the degenerate partition with a single set) is 2*

**W=V**^{n-1}, thus these many are the different cuts of

**. The weight of a cut is the sum of the weights of its edges.**

*G* The **Max-Cut Problem** calls for a cut of maximum weight among all cuts of ** G**.

#### Why Max-Cut is a logoptimization problem?

If we assign a binary variable ** x_{i }** to each node

**of**

*i***, every assignment of the values 0 or 1 to these variables will correspond to a partition of**

*V***. An edge**

*V***belongs to the cut associated with such a partition if and only if the values of**

*ij**and*

**x**_{i}**differ. Therefore, we would need a function of**

*x*_{j}*and*

**x**_{i}*that has value 1 when the two variables have different values and 0 otherwise. It is easy to verify that such a function can be expressed, using elementary arithmetic operations, as (1-*

**x**_{j}**)**

*x*_{i}**+**

*x*_{j}**(1 –**

*x*_{i}**). Then the weight of the cut can be expressed as the following polynomial of degree 2 in the variables**

*x*_{j}**with**

*x*_{i}**∈**

*i*

*V*:

**Σ**{**w**_{ij}( (1-**x**_{i})*+ (1-***x**_{j}*)***x**_{j}**x**_{i}**),**_{}**∈***ij***E***},*where **Σ** {**w**_{ij} ((1 – **x**_{i}) * x_{j}* + (1 –

*)*

**x**_{j}*),*

**x**_{i}

**∈**

*ij***E**} denotes the sum of the monomials

**w**

_{ij}((1 –

**x**

_{i})

*+*

**x**_{j}_{ }(1 –

*)*

**x**_{j}*) for all edges*

**x**_{i}*of*

**ij***Maximizing such a function is, evidently, a*

**G.***logoptimization*problem.

### SovingMax-Cut

The solution of Max-Cut to certified optimality is quite a difficult task for graphs of more than a few hundred nodes unless the graph is very sparse. However, techniques have been developed to provide good solutions to the problem along with a quality certificate.

A quality certificate is provided by computing an *upper bound *to the problem, i.e., a value that is mathematically guaranteed not to be below the optimal value. Once an upper bound has been computed, it is possible to evaluate the quality of a given cut by computing the gap between the bound and the cut weight. A simple upper bound can be computed by adding up the absolute value of the weights of all edges of the graph. However, such an upper bound, that is very fast to compute, would provide, in general, horribly large gaps also for cuts very close to the optimum. Therefore, the challenge is to design efficient procedures that can compute upper bounds that are reasonably close to the optimal value.

As said, fortunately, procedures have been developed that make it possible to find good cuts of very large graphs with a quality certified by a small gap. A very effective technique of this kind is based on the algorithm **SpeeDP ** described in

L. Grippo, L. Palagi, M. Piacentini, V. Piccialli, and G. Rinaldi:*SpeeDP: An algorithm to compute SDP bounds for very large Max-Cut instances*.

Mathematical Programming 136 (2012), 353-373,

were the solution of instances of sizes up to a million nodes is reported with gaps below 1%.

Our **LOGOPTIMIZE** server incorporates the SpeeDP algorithm and is able to handle very large instances of the problem, proving lower and upper bounds.