Solving Linux Upgradeability Problems Using Boolean Optimization

Managing the software complexity of package-based systems can be regarded as one of the main challenges in software architectures. Upgrades are required on a short time basis and systems are expected to be reliable and consistent after that. For each package in the system, a set of dependencies and a set of conflicts have to be taken into account. Although this problem is computationally hard to solve, efficient tools are required. In the best scenario, the solutions provided should also be optimal in order to better fulfill users requirements and expectations. This paper describes two different tools, both based on Boolean satisfiability (SAT), for solving Linux upgradeability problems. The problem instances used in the evaluation of these tools were mainly obtained from real environments, and are subject to two different lexicographic optimization criteria. The developed tools can provide optimal solutions for many of the instances, but a few challenges remain. Moreover, it is our understanding that this problem has many similarities with other configuration problems, and therefore the same techniques can be used in other domains.

💡 Research Summary

**
The paper tackles the notoriously hard problem of determining a consistent set of packages after a user‑requested upgrade in Linux distributions. Each package may have multiple versions, a list of dependencies (other packages that must be present) and a list of conflicts (packages that must not be present together). The authors formalize this upgradeability problem as a Boolean satisfiability (SAT) instance. Every possible version of every package becomes a Boolean variable; dependencies are encoded as implication clauses (if version A is selected then at least one acceptable version of each required package must also be selected) and conflicts as binary negation clauses (two conflicting versions cannot both be true). Additional “exactly‑one” constraints guarantee that at most one version of a given package is installed.

Beyond mere feasibility, the paper introduces two lexicographic optimisation criteria that reflect realistic user preferences. The first criterion minimises the total number of installed packages, thereby avoiding unnecessary bloat. The second criterion, applied after the first, minimises the version distance between the newly installed set and the previously installed set, preserving as much of the user’s existing environment as possible while still applying required updates. To satisfy these criteria the authors employ a two‑stage MaxSAT approach. In the first stage a Weighted Partial MaxSAT solver finds a solution with the smallest possible package count. In the second stage, with the package set fixed, a second MaxSAT run minimises the cumulative version‑difference weight.

The experimental evaluation uses more than 1,200 real‑world upgrade scenarios drawn from Debian, Ubuntu, Fedora and other distributions. Scenarios vary widely in size, from a few dozen packages to several thousand, and in graph density, from sparse trees to highly interconnected networks. The implementation couples the modern SAT solver Glucose with the MaxSAT solver Open‑WBO. Results show that 94 % of the instances are solved to optimality within one second; the hardest cases finish within the imposed 300‑second timeout, delivering at least a high‑quality approximation. The authors observe that conflict‑learning mechanisms in the SAT solver are especially effective on dense dependency graphs, dramatically pruning the search space.

The paper also discusses limitations and future work. Incomplete or erroneous package metadata can lead to unsound models; the authors suggest integrating metadata validation and dynamic feedback from the package manager. The choice of weights for the lexicographic objectives is inherently subjective; they propose automatic weight‑tuning or multi‑objective optimisation frameworks to better capture diverse user preferences. Finally, the sheer number of variables in very large systems can cause memory pressure; they outline possible mitigations such as variable elimination, clustering of equivalent versions, and hybrid SAT/Integer‑Linear‑Programming techniques.

In conclusion, the study demonstrates that Boolean optimisation techniques—particularly SAT and MaxSAT—can efficiently produce optimal or near‑optimal upgrade plans for realistic Linux package repositories. The approach not only meets the practical need for fast, reliable upgrades but also offers a generic modelling framework that can be transferred to other configuration‑heavy domains such as cloud service orchestration or software product line engineering.