[Rule] GraphPartitioning to ILP

[zazabap]

Source: GraphPartitioning
Target: ILP
Motivation: Enables solving graph bisection via ILP solvers; standard formulation used in VLSI partitioning tools.
Reference: Buluç, Meyerhenke, Safro, Sanders & Schulz, 2016

Reduction Algorithm

Notation:

• Source: undirected graph $G = (V, E)$, $n = |V|$ (even), $m = |E|$
• Target: ILP with binary variables, linear constraints, and a minimize objective

Variable mapping:

Partition variables: $x_i \in {0, 1}$ for each vertex $i \in V$ ($x_i = 1$ if $i \in B$).

Edge-crossing variables: $y_{uv} \in {0, 1}$ for each edge $(u, v) \in E$ ($y_{uv} = 1$ if the edge crosses the partition).

Constraints:

1. Balance: $\sum_{i \in V} x_i = n/2$

2. Crossing detection (for each edge $(u, v) \in E$):

   • $y_{uv} \geq x_u - x_v$
   • $y_{uv} \geq x_v - x_u$

Note: No explicit upper bound on $y_{uv}$ is needed — since the objective minimizes $\sum y_{uv}$, each $y_{uv}$ is driven to $|x_u - x_v|$ at optimality.

Objective: minimize $\sum_{(u,v) \in E} y_{uv}$

Solution extraction: $A = {i : x_i = 0}$, $B = {i : x_i = 1}$.

Size Overhead

Target metric (code name)	Polynomial (using symbols above)
num_vars	$n + m$
num_constraints	$2m + 1$

Validation Method

Closed-loop testing: solve GraphPartitioning by brute-force, solve the reduced ILP, and verify that both give the same optimal cut size.

Example

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

ILP: 15 variables ($x_0, \ldots, x_5$ + 9 edge variables), 19 constraints (18 crossing + 1 balance).

Optimal: $x = (0,0,0,1,1,1)$, $A = {0,1,2}$, $B = {3,4,5}$, objective $= 3$ crossing edges.

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	⚠️ Warn	Source "GraphPartitioning" not yet in codebase
Non-trivial	✅ Pass	Auxiliary edge-crossing variables + linearization constraints
Correctness	❌ Fail	DOI resolves to wrong paper
Well-written	✅ Pass	Complete algorithm, consistent symbols, correct example

Overall: 2 passed, 1 failed, 1 warning

---

Usefulness

GraphPartitioning does not exist in the codebase yet. A [Model] issue is a prerequisite before this rule can be implemented.

Non-trivial

Creates n²+n ILP variables (xᵢ partition indicators + y_uv crossing detectors) with linearization constraints y_uv ≥ |xᵤ − x_v| and a balance constraint. Genuine structural transformation.

Correctness — FAIL

Wrong DOI. The issue cites Brunetta, Conforti & Rinaldi (1997), but this DOI resolves to "Bound constrained quadratic programming via piecewise quadratic functions" — an unrelated paper.

Correct DOI: 10.1007/BF02614373 — "A branch-and-cut algorithm for the equicut problem," Mathematical Programming 78, 243–263 (1997).

The ILP formulation itself (crossing-detection linearization + balance constraint) is mathematically correct and standard.

Well-written

All sections present. Algorithm is step-by-step and implementable. Overhead metrics num_vars and num_constraints match ILP's size_fields. Example (6 vertices, 9 edges → 15 vars, 19 constraints, optimal cut=3) verified correct.

Note: Algorithm assumes n is even. Should address odd n handling.

Required fix

• Change DOI to 10.1007/BF02614373

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	⚠️ Warn	Source problem GraphPartitioning does not exist in the codebase; requires a new model first
Non-trivial	✅ Pass	Standard ILP formulation with edge-crossing auxiliary variables and balance constraint
Correctness	❌ Fail	DOI links to wrong paper; paper title mismatch
Well-written	⚠️ Warn	Minor issues: missing y_uv upper bound discussion; otherwise clear and complete

Overall: 1 passed, 0 failed on substance, 1 failed on references, 2 warnings

---

Usefulness

The source problem GraphPartitioning does not exist in the reduction graph. Running pred show GraphPartitioning fails. This means a [Model] issue and implementation for GraphPartitioning must be completed before this rule can be implemented. No existing path from GraphPartitioning to ILP exists (since the source problem is not yet in the system), so the reduction itself is novel.

Verdict: Warning — the rule is useful in principle, but depends on an unimplemented source model.

Non-trivial

The reduction introduces edge-crossing auxiliary variables y_uv for each edge, constructs linearized absolute-difference constraints to detect partition crossings, and adds a balance constraint. This is a genuine structural transformation — not a relabeling or subtype coercion. The formulation involves gadget-like construction (two linear constraints per edge to linearize |x_u - x_v|) and auxiliary variables.

Verdict: Pass.

Correctness

Reference verification failed.

The issue cites: Brunetta, Conforti & Rinaldi, 1997

• The DOI 10.1007/s101070050049 resolves to "Bound constrained quadratic programming via piecewise quadratic functions" — a completely different paper, not by Brunetta/Conforti/Rinaldi, and not about graph partitioning.
• The actual paper by Brunetta, Conforti & Rinaldi is "A branch-and-cut algorithm for the equicut problem", published in Mathematical Programming 78, pp. 243–263 (1997), with DOI 10.1007/BF02614373.
• Furthermore, their paper is about the equicut problem on complete graphs using a branch-and-cut approach with cutting planes on the edge polytope. It does not directly present the vertex-based ILP formulation described in this issue (which is a more standard textbook formulation). The paper's formulation uses edge variables on complete graphs with knapsack and triangle inequalities, which is different from the simpler vertex+edge variable formulation here.

The ILP formulation itself (vertex partition variables + edge-crossing variables + balance + linearized crossing detection) is a well-known standard formulation that appears in many textbooks and surveys on graph partitioning, but the specific citation does not match.

Verdict: Fail — the DOI is incorrect, and the cited paper does not contain the specific formulation described in the issue.

Well-written

Strengths:

• Clear step-by-step algorithm with numbered constraints
• Notation section defines all symbols before use
• Overhead table uses correct code metric names (num_vars, num_constraints) that match ILP's size_fields
• Example is fully worked with concrete instance, construction, and verified optimal solution
• Example size (6 vertices, 9 edges) is non-trivial yet brute-force verifiable
• Size overhead formulas are consistent with the algorithm: num_vars = n + m (partition + edge vars), num_constraints = 2m + 1 (2 constraints per edge + 1 balance)

Minor issues:

• The formulation does not explicitly state that y_uv is upper-bounded. While the minimization objective naturally keeps y_uv tight in an optimal solution, explicitly noting this (or adding y_uv <= 1 constraints) would improve clarity for implementers.
• The issue body could benefit from noting that this is a standard textbook formulation rather than attributing it specifically to Brunetta et al.

Verdict: Warning — substantively complete and implementable, but the reference attribution needs correction.

Recommendations

• Fix the DOI to 10.1007/BF02614373 if citing Brunetta, Conforti & Rinaldi (1997), or better yet, cite a textbook/survey that directly presents this vertex-based ILP formulation (e.g., the graph bisection survey by Buluc et al. or a standard combinatorial optimization textbook).
• A [Model] issue for GraphPartitioning must be created and implemented before this rule can proceed.
• Consider referencing Hager et al. "An exact algorithm for graph partitioning" (Math. Programming, 2013) which directly describes ILP formulations for general graph partitioning.

[isPANN]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	First reduction from GraphPartitioning; no existing path to ILP
Non-trivial	✅ Pass	Auxiliary edge-crossing variables + linearization constraints
Correctness	❌ Fail	DOI resolves to wrong paper; cited paper uses a different formulation
Well-written	✅ Pass	All sections complete, example brute-force verified correct

Overall: 3 passed, 1 failed, 0 warnings

---

Usefulness

GraphPartitioning exists in the codebase (pred show GraphPartitioning succeeds) but currently has zero reductions (both reduces_from and reduces_to are empty). No path from GraphPartitioning to ILP exists. This would be the first outgoing edge from GraphPartitioning, connecting it to the broader reduction graph via ILP.

Motivation is concrete: "Enables solving graph bisection via ILP solvers; standard formulation used in VLSI partitioning tools."

Verdict: Pass.

Non-trivial

The reduction introduces m auxiliary edge-crossing variables y_uv, constructs 2m linearized absolute-difference constraints (y_uv ≥ x_u − x_v, y_uv ≥ x_v − x_u), and adds a balance constraint. This is a genuine structural transformation — not a relabeling, subtype coercion, or identity mapping. The gadget-like linearization of |x_u − x_v| into two linear inequalities is a standard but non-trivial technique.

Verdict: Pass.

Correctness

Reference verification failed.

1. Wrong DOI. The cited DOI 10.1007/s101070050049 resolves to "Bound constrained quadratic programming via piecewise quadratic functions" by Madsen, Nielsen & Pinar (Mathematical Programming 85, 1999) — an unrelated paper about quadratic programming.

2. Correct DOI for Brunetta et al. The actual paper is "A branch-and-cut algorithm for the equicut problem" by L. Brunetta, M. Conforti, G. Rinaldi (Mathematical Programming 78, pp. 243–263, 1997), DOI: 10.1007/BF02614373.

3. Formulation mismatch. Even with the correct DOI, the Brunetta et al. paper uses a polyhedral edge-incidence-vector formulation on complete graphs with cutting planes and facet inequalities — a fundamentally different approach from the simple vertex-partition + edge-crossing ILP formulation described in this issue.

4. The ILP formulation itself is mathematically correct. Brute-force verification (all 20 balanced bisections of the 6-vertex graph) confirms the optimal cut size is 3, matching the claimed solution. The ILP with 15 variables and 19 constraints produces the same optimum with correct round-trip (328 feasible ILP assignments enumerated, 2 optimal — corresponding to the two symmetric partitions).

Recommendation: Replace the reference with one that directly presents this vertex-based ILP formulation. Candidates:

• Hager, Phan & Zhang, "An exact algorithm for graph partitioning", Mathematical Programming 2013, DOI: 10.1007/s10107-011-0503-x
• Wolsey, Integer Programming (textbook) — covers standard linearization of absolute-value constraints
• Ferreira, Martin, de Souza, Weismantel & Wolsey, "Formulations and valid inequalities for the node capacitated graph partitioning problem", Mathematical Programming 1998

Verdict: Fail.

Well-written

Required sections: All present and substantive — Source, Target, Motivation, Reference, Reduction Algorithm, Size Overhead, Validation Method, Example. ✅

Algorithm completeness: Step-by-step with numbered constraints, all intermediate values defined, solution extraction stated. ✅

Symbol consistency: All symbols (G, V, E, n, m, x_i, y_uv) defined in the Notation block before first use and consistent across sections. ✅

Overhead metrics: num_vars = n + m, num_constraints = 2m + 1 match ILP's size_fields (num_vars, num_constraints). Verified against constructed example: 6+9=15 vars, 2×9+1=19 constraints. ✅

Example quality: 6 vertices, 9 edges → 20 balanced bisections (search space appropriate). Fully worked: shows source graph, ILP dimensions, and optimal partition. 18 suboptimal feasible solutions exist. Brute-force Python verification confirms all claims. ✅

Minor note: The algorithm assumes n is even. Handling for odd n is not discussed, but this could be addressed during implementation.

Verdict: Pass.

Recommendations

• Fix the DOI — either to 10.1007/BF02614373 (Brunetta et al.) or replace with a reference that directly presents this vertex-based ILP formulation (e.g., Hager et al. 2013)
• Note in the reference section that this is a standard textbook formulation rather than attributing it specifically to Brunetta et al.
• Consider addressing odd-n handling (or state that the model requires even n)