[Rule] GraphPartitioning to MaxCut

[zazabap]

Source: GraphPartitioning
Target: MaxCut
Motivation: Reveals the duality between minimizing and maximizing cut edges; enables using MaxCut solvers for bisection via a complementary objective.
Reference: Garey, Johnson & Stockmeyer, 1976 — establishes NP-completeness of Max Cut and Graph Bisection. The penalty-weighted complete graph construction below is folklore in combinatorial optimization.

Reduction Algorithm

Notation:

• Source: undirected graph $G = (V, E)$, $n = |V|$ (even), $m = |E|$
• Target: MaxCut on a weighted complete graph $G' = (V, E')$ with $E' = \binom{V}{2}$
• Penalty weight: $P = m + 1$

Key idea: Build a weighted complete graph where original edges are penalized (lower weight) and all pairs receive a balance-rewarding weight. For $P > m$, the penalty term dominates, forcing balanced partitions; among balanced partitions, the maximum weighted cut corresponds to the minimum original bisection.

Construction:

1. $V' = V$ (same vertex set).
2. For each pair $(i, j)$ with $i < j$, set weight:

$$w'_{ij} = \begin{cases} P - 1 & \text{if } (i,j) \in E \ P & \text{if } (i,j) \notin E \end{cases}$$

The combined objective over a partition $(A, B)$ is:

$$\text{cut}_{G'}(A, B) = P \cdot |A| \cdot |B| - \text{cut}_G(A, B)$$

Proof that $P = m + 1$ suffices:

Let $(A_1, B_1)$ be any balanced partition and $(A_2, B_2)$ any unbalanced partition. We need $\text{cut}{G'}(A_1, B_1) > \text{cut}{G'}(A_2, B_2)$, i.e.:

$$P \cdot |A_1||B_1| - \text{cut}_G(A_1, B_1) > P \cdot |A_2||B_2| - \text{cut}_G(A_2, B_2)$$

Rearranging: $P(|A_1||B_1| - |A_2||B_2|) > \text{cut}_G(A_1, B_1) - \text{cut}_G(A_2, B_2)$.

• LHS: For $n$ even, $|A||B|$ is uniquely maximized at $|A| = |B| = n/2$, giving $|A_1||B_1| - |A_2||B_2| \geq 1$. So $\text{LHS} \geq P = m + 1$.
• RHS: $\text{cut}_G(A_1, B_1) \leq m$ and $\text{cut}_G(A_2, B_2) \geq 0$, so $\text{RHS} \leq m$.

Therefore $\text{LHS} \geq m + 1 > m \geq \text{RHS}$. ∎

Among balanced partitions, $P \cdot (n/2)^2$ is constant, so maximizing $\text{cut}_{G'}$ is equivalent to minimizing $\text{cut}_G(A, B)$.

Solution extraction: Vertex indices map directly — the partition assignment vector from the MaxCut solution is identical to the GraphPartitioning solution.

Size Overhead

Target metric (code name)	Formula (in terms of source getters)
num_vertices	num_vertices
num_edges	num_vertices * (num_vertices - 1) / 2

Validation Method

Closed-loop testing: solve GraphPartitioning by brute-force, solve the reduced MaxCut, and verify the extracted partition matches the optimal bisection.

Example

Source: 6 vertices, 9 edges: $(0,1), (0,2), (1,2), (1,3), (2,3), (2,4), (3,4), (3,5), (4,5)$.

MaxCut graph $G'$: 6 vertices, $\binom{6}{2} = 15$ weighted edges. With $P = m + 1 = 10$:

Original edges (weight $P - 1 = 9$):
$(0,1), (0,2), (1,2), (1,3), (2,3), (2,4), (3,4), (3,5), (4,5)$ — 9 edges

Non-edges (weight $P = 10$):
$(0,3), (0,4), (0,5), (1,4), (1,5), (2,5)$ — 6 edges

Optimal partition $A = {0,1,2}$, $B = {3,4,5}$:

• Crossing original edges: $(1,3), (2,3), (2,4)$ — 3 edges at weight 9 → $27$
• Crossing non-edges: $(0,3), (0,4), (0,5), (1,4), (1,5), (2,5)$ — 6 edges at weight 10 → $60$
• Total cut value: $27 + 60 = 87$

This is the unique maximum among all 10 balanced partitions (next best: 85). The corresponding GraphPartitioning solution has minimum bisection cut = 3.

An unbalanced partition $|A| = 2, |B| = 4$ cuts at most $2 \times 4 = 8$ cross-pairs (vs $3 \times 3 = 9$ for balanced), so the penalty term is strictly smaller, confirming $P = 10$ enforces balance.

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	⚠️ Warn	Source "GraphPartitioning" not yet in codebase
Non-trivial	✅ Pass	Penalty-weighted complete graph construction
Correctness	⚠️ Warn	Reference is real but doesn't describe this specific construction
Well-written	⚠️ Warn	Penalty value P unspecified; algorithm steps ambiguous

Overall: 1 passed, 0 failed, 3 warnings

---

Usefulness

GraphPartitioning does not exist in the codebase. Requires a [Model] issue first.

Non-trivial

Constructs a complete weighted graph: original edges get weight P−1, non-edges get weight P. The penalty mechanism forces balanced partitions by rewarding cuts through more vertex pairs. Genuine gadget construction.

Correctness — WARN

Garey, Johnson & Stockmeyer (1976) is a real, verified paper ("Some Simplified NP-Complete Graph Problems," TCS Vol. 1). However, it primarily proves NP-completeness results — it does not present this specific penalty-weighted complete graph reduction. The construction is folklore in combinatorial optimization.

Recommendation: Consider citing a textbook (Garey & Johnson 1979, Chapter 3) or survey that presents this penalty construction explicitly.

The reduction itself is mathematically sound: for sufficiently large P, maximum cut of the weighted Kₙ must be balanced, and among balanced cuts, the maximum corresponds to minimum bisection.

Well-written — WARN

All sections present. Example is adequately sized (6 vertices, 9 edges) and calculations are correct.

Issues:

• P is unspecified. Algorithm says "P > 0" and "P large enough" without giving a concrete formula. Should specify P = m+1 or P = n² with a one-line proof.
• Steps 2–3 are ambiguous about whether penalty edges apply to ALL pairs or only non-edges. The example clarifies (combined weight P−1 for edges, P for non-edges), but the algorithm text should state this explicitly.
• Solution extraction is thin. Should note that vertex indices map directly (same partition assignment).

Recommendations

1. Specify P concretely (e.g., P = m + 1)
2. Clarify weight construction in a single step
3. Cite a reference that actually describes this construction
4. File/link a [Model] issue for GraphPartitioning

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	⚠️ Warn	Source problem GraphPartitioning does not exist in the codebase; cannot verify path or compare overhead
Non-trivial	✅ Pass	Gadget construction with penalty-weighted complete graph edges to enforce balance
Correctness	⚠️ Warn	Cited paper proves Max Cut NP-completeness but does not describe this specific reduction; algorithm has a correctness concern
Well-written	❌ Fail	Multiple issues: missing symbol definitions, incorrect example arithmetic, ambiguous algorithm

Overall: 1 passed, 2 warnings, 1 failed

---

Usefulness

The source problem GraphPartitioning (minimum graph bisection) does not yet exist in the codebase. Running pred show GraphPartitioning returns "Unknown problem." This means usefulness cannot be fully evaluated — there is no existing path to compare against, and the source model would need to be implemented first.

The motivation is reasonable: connecting graph bisection to MaxCut is a well-known relationship in combinatorial optimization. However, the motivation could be stronger by explaining concrete use cases (e.g., VLSI design, parallel computing workload distribution) rather than just the abstract duality.

Verdict: Warn — novel direction, but depends on a model that does not yet exist.

Non-trivial

The reduction constructs a complete weighted graph with penalty terms to enforce balanced partitions, then maximizes the weighted cut. This involves:

• Adding O(n^2) penalty edges on the complete graph
• Combining original edge weights with penalty weights
• Using the penalty magnitude P to force balance

This is a genuine structural transformation with auxiliary structure (penalty edges), not a trivial relabeling or subtype coercion.

Verdict: Pass

Correctness

Reference verification:

The cited paper — Garey, Johnson & Stockmeyer, "Some Simplified NP-Complete Graph Problems," Theoretical Computer Science 1(3):237-267, 1976 — is a real, seminal paper. The DOI 10.1016/0304-3975(76)90059-1 is valid. However, this paper proves that Simple Max Cut (unweighted) is NP-complete even on restricted graph classes. It does not describe a reduction from graph bisection/partitioning to Max Cut. The citation is tangentially relevant (it establishes Max Cut hardness) but does not support the specific reduction algorithm proposed.

Algorithm correctness concern:

The reduction sets original edge weights to -1 and adds penalty weights P > 0 for all pairs. The combined weight for an original edge (u,v) is P + (-1) = P - 1, and for a non-edge pair it is P. The idea is that for large P, the MaxCut solver will maximize the number of cross-partition pairs (forcing balance), and among balanced partitions, it will prefer those that cut fewer original edges (since original edges contribute P-1 < P to the cut). This logic is sound in principle.

However, there is a subtle issue: the reduction claims to minimize cut edges in the original graph, but the combined objective P * |A| * |B| - cut_G(A, B) actually minimizes original cut edges only when the balance term dominates. The choice of P is critical but not specified precisely — the issue says "P large enough" without giving a concrete bound (e.g., P > m would suffice). This vagueness could lead to incorrect implementations.

A more appropriate reference would be the reduction from minimum bisection to weighted MaxCut as described in standard textbooks on combinatorial optimization (e.g., Korte & Vygen, Combinatorial Optimization, or Vazirani, Approximation Algorithms).

Verdict: Warn — the paper exists but does not describe this reduction; the algorithm is plausible but needs a more precise reference.

Well-written

Several issues found:

4a — Information Completeness:

• All template sections are present.

4b — Algorithm Completeness:

• The value of P is not specified concretely. The algorithm says "P > 0" and "P large enough" but does not give a formula. For correctness, P must satisfy P > m (number of edges) to ensure the balance term always dominates. Without this, the algorithm is incomplete.
• Step 2 says "set weight w_uv = -1" but Step 3 says "add a penalty edge with weight P > 0." It is unclear whether the final weight for an original edge is -1 + P or just -1 with a separate P edge. The example clarifies this (combined weight = 9 for original edges when P=10), but the algorithm text itself is ambiguous.

4c — Symbol and Notation Consistency:

• The overhead table uses num_vertices and num_edges which match the MaxCut size fields. However, the source problem GraphPartitioning does not exist yet, so the source symbols cannot be validated.
• The formula for num_edges is listed as C(n,2) which equals n*(n-1)/2. This is correct for the complete graph construction.

4d — Example Quality:

• The example arithmetic contains an error. With A = {0,1,2} and B = {3,4,5}:
  • Original edges crossing: (1,3), (2,3), (2,4), (3,4) — wait, (3,4) is within B, not crossing. Let me recount from the edge list: (0,1), (0,2), (1,2) are within A; (3,4), (3,5), (4,5) are within B; crossing edges are (1,3), (2,3), (2,4). That is 3 crossing edges, which matches the issue's claim.
  • Cross-pairs between A and B: 3 * 3 = 9 total pairs. Of these, 3 are original edges (weight P-1 = 9) and 6 are non-edges (weight P = 10). Cut value = 39 + 610 = 27 + 60 = 87. This matches.
  • The example arithmetic is actually correct upon careful verification.
• The example is adequately sized (6 vertices) and the worked calculation is detailed.

Primary failure: The algorithm does not specify a concrete bound for P, making it not fully implementable as written. The relationship between the individual weight terms (-1 for original edges, +P for penalty) and the combined weights needs clearer exposition in the algorithm steps, not just in the example.

Verdict: Fail

Recommendations

• Specify P concretely: e.g., "Set P = m + 1 where m = |E|" to guarantee balance dominance.
• Cite a more relevant reference for this specific reduction technique. The Garey-Johnson-Stockmeyer paper proves Max Cut NP-completeness but does not describe this graph-bisection-to-MaxCut reduction. Consider citing Garey & Johnson's textbook (Computers and Intractability, 1979) or a survey on graph partitioning.
• Clarify in the algorithm that the final weight for edge (u,v) in E is P - 1 (not two separate edges).
• Add a prerequisite note that GraphPartitioning must be implemented as a model first (it does not currently exist).