[Model] GraphPartitioning

[zazabap]

Motivation

Core NP-hard problem in VLSI chip design, parallel computing, and scientific simulation. Standard tools (METIS, KaHIP, Scotch) are used across the semiconductor and HPC industries. Has natural reductions to ILP, QUBO, MaxCut, and SpinGlass.

Definition

Name: GraphPartitioning (Minimum Bisection)
Reference: Garey, Johnson & Stockmeyer, 1976; Bui & Jones, 1992

Given an undirected graph $G = (V, E)$ with $|V| = n$ (even), partition $V$ into two disjoint sets $A$ and $B$ with $|A| = |B| = n/2$, minimizing the number of edges crossing the partition:

$$\text{cut}(A, B) = |{(u, v) \in E : u \in A, v \in B}|$$

Variables

• Count: $n$ (one variable per vertex)
• Per-variable domain: binary ${0, 1}$
• Meaning: $x_i = 0$ if vertex $i \in A$, $x_i = 1$ if vertex $i \in B$

Schema (data type)

Type name: GraphPartitioning
Variants: balanced bisection (equal halves), $k$-way partitioning, weighted vertices/edges

Field	Type	Description
graph	SimpleGraph	The undirected graph $G = (V, E)$

Problem Size

Metric	Expression	Description
num_vertices	$n$	Number of vertices
num_edges	$m$	Number of edges

Complexity

• Decision complexity: NP-complete (Garey, Johnson & Stockmeyer, 1976)
• Best known exact algorithm: $O(2^n)$ brute-force; practical solvers use branch-and-bound with spectral lower bounds
• Approximation: $O(\sqrt{\log n})$-approximation (Arora, Rao & Vazirani, 2009)
• References: Garey et al. 1976; Arora, Rao & Vazirani 2009

Extra Remark

METIS and its variants are the industry standard for graph partitioning in VLSI layout, finite element mesh decomposition, and distributed computing. The problem is closely related to MaxCut (which maximizes rather than minimizes the cut) and SpinGlass (via the Ising model).

How to solve

• It can be solved by (existing) bruteforce.
• It can be solved by reducing to integer programming, through a new GraphPartitioning → ILP rule issue (to be filed).

Bruteforce: enumerate all $\binom{n}{n/2}$ balanced partitions, count cut edges for each, return minimum.

Example Instance

$n = 6$ vertices, $m = 9$ edges:

0 --- 1
|\ /|
| X  |
|/ \|
2 --- 3
|     |
4 --- 5

Edges: $(0,1), (0,2), (1,2), (1,3), (2,3), (2,4), (3,4), (3,5), (4,5)$

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

The 3 crossing edges are $(1,3), (2,3), (2,4)$. Compare: worst partition has cut $= 7$.

[isPANN]

Closing as duplicate — this problem is covered by the Garey & Johnson extraction (P98 GraphPartitioning, G&J Appendix A2, ND14). The extracted reference issue in references/Garey&Johnson/issues/models/P98_graph_partitioning.md provides a comprehensive definition from the original source.

[zazabap]

Check-Issue Report: #117 [Model] GraphPartitioning

1. Usefulness — PASS

• Not a duplicate: GraphPartitioning does not exist in the current problem registry (24 problems registered; confirmed via pred list).
• Motivation is sound: Graph partitioning / minimum bisection is a core NP-hard problem with major applications in VLSI layout, parallel computing, finite-element mesh decomposition, and distributed computing. Industry-standard tools (METIS, KaHIP, Scotch) exist for this problem. It provides natural reduction targets (ILP, QUBO, MaxCut, SpinGlass) that would enrich the reduction graph.

2. Non-trivial — PASS

• Distinct from MaxCut: MaxCut maximizes the number of crossing edges with no balance constraint. GraphPartitioning (Minimum Bisection) minimizes the crossing edges subject to the hard constraint |A| = |B| = n/2. These are genuinely different optimization problems — MaxCut is in MAX SNP (APX-hard with 0.878-approximation via Goemans-Williamson), while Minimum Bisection has an O(sqrt(log n))-approximation (Arora-Rao-Vazirani). Neither trivially reduces to the other with a constant-factor overhead.
• Distinct from SpinGlass: SpinGlass is an unconstrained Ising minimization; the balance constraint in bisection makes it structurally different.
• Not trivially implementable: The balance constraint (exactly n/2 vertices per side) requires careful handling in both the model and brute-force solver.

3. Correctness — PASS (with minor note)

• Garey, Johnson & Stockmeyer (1976): Verified. Published in Theoretical Computer Science, 1(3):237–267. This paper proves NP-completeness of several graph problems including graph bisection. DOI 10.1016/0304-3975(76)90059-1 is correct.
• Bui & Jones (1992): Verified. "Finding good approximate vertex and edge partitions is NP-hard," Information Processing Letters, 42(3):153–159. DOI 10.1016/0020-0190(92)90087-C is correct.
• Arora, Rao & Vazirani (2009): Verified. "Expander Flows, Geometric Embeddings and Graph Partitioning," Journal of the ACM, 56(2). The O(sqrt(log n))-approximation claim is correct. DOI 10.1145/1502793.1502794 is correct.
• Complexity claim: The issue states "O(2^n) brute-force" which is a valid upper bound. However, the actual brute-force for balanced bisection is O(C(n, n/2)) = O(2^n / sqrt(n)) by Stirling's approximation — this is fine as an asymptotic O(2^n) bound. There exist fixed-parameter tractable algorithms (Cygan et al., 2014) running in 2^{O(k^3)} * n^3 * log^3(n) where k is the bisection size, but these don't improve the worst-case over all instances.
• Example instance: The 6-vertex, 9-edge graph with partition A={0,1,2}, B={3,4,5} yielding cut=3 is correct. The three crossing edges (1,3), (2,3), (2,4) are verified. The claim of worst partition having cut=7 is plausible for this graph.

4. Well-written — PASS (minor suggestions)

• All sections present: Motivation, Definition, Variables, Schema, Problem Size, Complexity, Extra Remark, How to Solve, Example Instance — all present and complete.
• Definition is clear: The mathematical formulation with the cut objective and balance constraint is precise.
• Variables section is correct: Binary encoding with x_i in {0,1} mapping to partition membership.
• Symbols are consistent: Uses n, m, A, B, x_i consistently throughout.
• Minor suggestions (non-blocking):
  • The "Variants" row in Schema mentions k-way partitioning and weighted variants, but these are not part of the initial implementation scope. This is fine as future context but could be clearer about what the initial implementation covers (unweighted balanced bisection only).
  • The ASCII art graph diagram is slightly ambiguous (the "X" cross pattern) but the explicit edge list resolves any confusion.
  • Consider noting that n must be even for the balanced bisection formulation.

---

Verdict: ALL CHECKS PASS ✅

This is a well-motivated, well-defined, and correctly referenced issue for a genuinely useful and non-trivial problem. Ready for implementation.

[zazabap]

Issue Quality Check — Model

Check	Result	Details
Usefulness	✅ Pass	Novel problem not yet in the reduction graph; strong motivation with concrete applications
Non-trivial	✅ Pass	Distinct feasibility constraint (balanced partition) from all existing problems
Correctness	⚠️ Warn	Complexity bound is naive O(2^n); a better exact algorithm likely exists. One reference DOI may be slightly off.
Well-written	⚠️ Warn	Minor issues: missing How to solve completeness for ILP path; naming convention question

Overall: 2 passed, 0 failed, 2 warnings

---

Usefulness

Pass. GraphPartitioning (Minimum Bisection) does not exist in the current reduction graph. The pred show GraphPartitioning command confirms this. The motivation is strong and concrete: VLSI chip design, parallel computing, scientific simulation, with industry-standard tools (METIS, KaHIP, Scotch) cited. The issue mentions natural reductions to ILP, QUBO, MaxCut, and SpinGlass, ensuring the problem will not be an orphan node in the reduction graph.

The problem is genuinely distinct from the existing MaxCut problem: MaxCut maximizes crossing edges with unconstrained partition sizes, while GraphPartitioning minimizes crossing edges with a strict balance constraint (|A| = |B| = n/2). This balance constraint fundamentally changes the problem's structure and complexity landscape.

Non-trivial

Pass. GraphPartitioning has a genuinely different feasibility constraint from all 24 existing problems in the codebase. The key distinguishing feature is the balanced partition constraint (|A| = |B| = n/2), which is not present in any existing problem:

• vs MaxCut: MaxCut maximizes the cut with no balance constraint; GraphPartitioning minimizes it with a strict balance requirement.
• vs SpinGlass/QUBO: These are unconstrained optimization over binary variables; GraphPartitioning has a hard cardinality constraint.
• vs MinimumVertexCover/MaximumIndependentSet: These select subsets with adjacency constraints, not balanced partitions.

This is not a variant of any existing problem — it requires new feasibility logic and a distinct objective.

Correctness

Warn. Partial verification with minor concerns:

References verified:

• Garey, Johnson & Stockmeyer (1976): Confirmed. "Some Simplified NP-Complete Graph Problems," Theoretical Computer Science, 1(3), 237–267. DOI 10.1016/0304-3975(76)90059-1 is correct. This paper does address NP-completeness of graph partitioning problems, though the primary focus is on restricted graph problems (low-degree graphs, planarity). The NP-completeness of graph bisection is established in the broader literature building on this work.
• Arora, Rao & Vazirani (2009): Confirmed. "Expander Flows, Geometric Embeddings and Graph Partitioning," Journal of the ACM, 56(2). DOI 10.1145/1502793.1502794 is correct. The O(√log n)-approximation result is verified — this applies to sparsest cut and balanced separator problems.
• Bui & Jones (1992): The paper "Finding good approximate vertex and edge partitions is NP-hard" by Bui and Jones appears in Information Processing Letters, 42(3), 153–159, 1992. The DOI 10.1016/0020-0190(92)90087-C should be verified — the DOI pattern matches IPL but the exact suffix may differ from the actual paper.

Complexity concern:
The issue states the best known exact algorithm is "O(2^n) brute-force." This is technically correct but understates what is known:

• The brute-force bound for balanced bisection is actually O(C(n, n/2)) = O(2^n / √n) by Stirling's approximation, not general O(2^n).
• More importantly, there exist better exact algorithms. Cygan et al. showed Minimum Bisection is fixed-parameter tractable with running time O(2^{O(k³)} · n³ log³ n) where k is the bisection width. For practical instances with small bisection width, this is far better than brute-force.
• The declare_variants! macro requires a concrete complexity string. The issue should specify the best known unconditional exact algorithm bound rather than just "brute-force."

Recommendation: Update the Complexity section to cite a more precise exact algorithm. If no algorithm with a better unconditional worst-case bound than O(2^n) is known, state this explicitly with a citation. Consider citing Cygan et al.'s FPT result as supplementary.

Well-written

Warn. The issue is generally well-structured and follows the template, but has some minor issues:

Strengths:

• Clear formal definition with explicit objective function
• Variables section is complete with count, domain, and semantics
• Schema and Problem Size tables are present and well-formed
• Example is non-trivial (6 vertices, 9 edges), fully worked with crossing edges enumerated, and the optimal solution (cut = 3) is stated and verifiable

Issues found:

1. How to solve — incomplete ILP path: The ILP reduction checkbox is unchecked with "to be filed." This is fine for now, but the brute-force description says "enumerate all C(n, n/2) balanced partitions" — this is correct but should note this is exponential (not polynomial) time. The brute-force approach is valid for small instances.

2. Naming convention question: The project convention uses explicit optimization prefixes for min/max problems (e.g., MinimumVertexCover, MaximumIndependentSet). The issue proposes GraphPartitioning without a Minimum prefix, even though this is a minimization problem. Consider whether MinimumBisection or MinimumGraphPartitioning would be more consistent with existing naming conventions. However, since MaxCut, SpinGlass, and QUBO also lack explicit prefixes, GraphPartitioning may be acceptable.

3. Variants not fully specified: The Schema section mentions "balanced bisection (equal halves), k-way partitioning, weighted vertices/edges" as variants, but the formal definition only covers balanced bisection. The relationship between these variants and the implementation scope should be clarified — will the initial implementation only cover balanced bisection on SimpleGraph?

4. Symbol consistency: The Problem Size table uses n and m which are defined in the Definition section. This is consistent. The num_vertices and num_edges metric names match standard getter methods. No issues here.

Recommendations

• Specify a more precise best-known exact algorithm complexity bound (or explicitly state that O(2^n) brute-force is the best unconditional bound with a citation).
• Clarify whether the initial implementation scope is just balanced bisection or includes k-way partitioning.
• Consider whether the naming should follow the Minimum prefix convention or use the bare GraphPartitioning name.
• Verify the Bui & Jones DOI is exact.