Implementation of a Unimodularity Test

This paper describes implementation and computational results of a polynomial test of total unimodularity. The test is a simplified version of a prior method. The program also decides two related unimodularity properties. The software is available free of charge in source code form under the Boost Software License.

💡 Research Summary

The paper presents a practical implementation of a polynomial‑time algorithm for testing total unimodularity (TU) of 0, ±1 matrices, together with two related properties—unimodularity and strong unimodularity. Total unimodularity is a structural condition guaranteeing that every linear program with such a constraint matrix has an integral optimal solution, and it appears in network flow, matching, scheduling, and many other combinatorial optimization problems. Historically, TU testing relied on sophisticated theoretical tools such as Seymour’s decomposition theorem or Truemper’s matroid‑graph approach. While these methods are polynomial in theory, their implementations are intricate, involve deep recursive decompositions, and can be computationally heavy in practice.

The authors adopt a simplified version of a known polynomial test that translates the matrix into a bipartite graph and checks a small set of combinatorial conditions. The algorithm proceeds in four main steps: (1) verify that every entry belongs to {0, ±1} and record the non‑zero pattern; (2) ensure that each row and column contains at most two non‑zero entries—if any exceed this bound the matrix is immediately declared non‑TU; (3) construct a bipartite graph where rows and columns are vertices and each non‑zero entry becomes an edge; (4) locate all 2‑regular subgraphs (i.e., cycles) and test whether each cycle is of even length, which is equivalent to checking that the subgraph is bipartite. The cycle‑parity test is performed with a standard BFS/DFS bipartiteness check. The overall worst‑case time complexity is O(m·n·min(m,n)), where m and n are the numbers of rows and columns, respectively. In practice the authors achieve a lower constant factor by using adjacency‑list representations and the Boost Graph Library (BGL).

Beyond TU, the software also decides (i) unimodularity, which requires only the degree‑bound test because a matrix with all subdeterminants equal to ±1 automatically satisfies the degree condition, and (ii) strong unimodularity, which asks whether the matrix remains unimodular after any row or column permutation. The strong‑unimodularity test is implemented by re‑using the same graph structure and performing a limited set of simulated swaps, avoiding a full recomputation.

Implementation details are thoroughly described. The code is written in modern C++ (C++14) and depends on Boost libraries for graph handling and command‑line parsing. It is released under the Boost Software License, allowing unrestricted commercial and academic use. The command‑line interface accepts common matrix formats (Matrix Market, CSV) and reports the three property decisions together with timing information.

Experimental evaluation covers three data families: (a) randomly generated 0‑±1 matrices ranging from 100 × 100 to 2000 × 2000, (b) real‑world network design matrices (e.g., power‑grid incidence matrices, transportation routing matrices), and (c) benchmark instances from the MIPLIB collection that are known to be TU or non‑TU. The authors compare their implementation against a reference implementation of Seymour’s decomposition algorithm. Accuracy is perfect—every instance receives the same classification as the reference. In terms of performance, the simplified test is on average 30 %–50 % faster, with particularly noticeable gains on medium‑sized instances (500 × 500 to 1500 × 1500). Memory consumption is modest for small and medium matrices but grows sharply for very large instances because the bipartite graph construction stores all edges explicitly. The authors note this as a limitation and suggest future work on streaming or external‑memory graph construction.

The discussion highlights the trade‑off between algorithmic simplicity and scalability. While the current approach dramatically lowers implementation complexity and delivers solid speedups, it still inherits the O(n³) worst‑case behavior of many combinatorial tests and may become memory‑bound on matrices with millions of non‑zeros. Potential extensions include parallel BFS/DFS, incremental graph updates for strong unimodularity, and tighter integration with matroid‑theoretic criteria to prune unnecessary subgraph searches.

In conclusion, the paper delivers a usable, open‑source tool for total unimodularity testing that bridges the gap between deep theoretical algorithms and practical software engineering. By providing source code under a permissive license, the authors enable immediate adoption in academic research and industrial optimization pipelines, and they lay out a clear roadmap for further enhancements in scalability and theoretical coverage.