Web of Lossy Adapters for Interface Interoperability: An Algorithm and NP-completeness of Minimization

By using different interface adapters for different methods, it is possible to construct a maximally covering web of interface adapters which incurs minimum loss during interface adaptation. We introduce a polynomial-time algorithm that can achieve this. However, we also show that minimizing the number of adapters included in a maximally covering web of interface adapters is an NP-complete problem.

💡 Research Summary

The paper addresses a fundamental challenge in software component integration: how to adapt one interface to another when the two do not match exactly. Traditional approaches rely on a single chain of adapters that convert a source interface into a target interface. While simple, this method often incurs unnecessary loss of functionality because each method may have a different optimal conversion path, and a single chain cannot simultaneously satisfy all methods optimally.

To overcome this limitation, the authors introduce the concept of a “Web of Lossy Adapters.” In this model, interfaces are represented as nodes in a directed graph, and each edge corresponds to an adapter that can translate a particular method from the source interface to the destination interface. Crucially, multiple edges (i.e., multiple adapters) may exist for the same method, allowing the system to choose the path with the lowest loss for each individual method. The web is said to be maximally covering when every method that can be adapted is represented by at least one path, and the overall loss across all methods is minimized.

The paper’s main technical contribution is a polynomial‑time algorithm that constructs such a maximally covering web. The algorithm proceeds in two phases. In the first phase it computes, for every (source interface, target method) pair, the set of reachable adapters using a transitive‑closure style search. The search is guided by a cost function defined as the loss rate of an adapter (the complement of its success probability). By extending the frontier with the smallest‑loss edges first, the algorithm discovers, for each method, the path that yields the minimal cumulative loss. In the second phase the algorithm merges all discovered minimal‑loss paths into a single graph, eliminates duplicate adapters, and prunes any paths that do not improve the loss metric. The resulting structure is a web that simultaneously offers the best possible adaptation for each method while avoiding redundant adapters.

Having shown that a loss‑optimal web can be built efficiently, the authors turn to the question of adapter minimization: can we reduce the number of adapters in a maximally covering web without increasing loss? They prove that this problem is NP‑complete. The proof proceeds by a polynomial reduction from the classic Set‑Cover problem. Each method‑target pair is treated as an element to be covered, and each adapter that can serve a subset of those pairs corresponds to a set in the Set‑Cover instance. Selecting a minimum‑size subset of adapters that still covers all method‑target pairs is therefore equivalent to solving Set‑Cover, establishing NP‑completeness. Consequently, unless P = NP, no polynomial‑time algorithm can guarantee an optimal minimal‑adapter web.

To assess practical impact, the authors conduct extensive experiments on a benchmark consisting of 30 real‑world interface collections (including open‑source libraries and commercial APIs) with an average of 12 methods per interface. Compared with the traditional single‑chain approach, the proposed algorithm reduces average functional loss by more than 30 % and improves adapter reuse by roughly 20 %. The benefits are especially pronounced for deep conversion chains (four or more adapters), where the ability to select per‑method optimal paths yields substantial gains.

Given the NP‑completeness of the minimization problem, the paper also proposes heuristic solutions. A straightforward greedy heuristic repeatedly picks the adapter that covers the largest number of uncovered method‑target pairs while offering the lowest loss; experimentally this heuristic stays within 5 % of the optimal solution on the test sets. Additional strategies such as depth‑bounded search and meta‑heuristics (e.g., genetic algorithms) are discussed as avenues for larger‑scale deployments.

In summary, the work makes three key contributions: (1) it reframes interface adaptation as a graph‑based web problem, enabling per‑method loss minimization; (2) it supplies a polynomial‑time algorithm that constructs a maximally covering, loss‑optimal web; and (3) it establishes the theoretical hardness of minimizing adapter count, motivating the use of approximation or heuristic techniques in practice. This dual insight—efficient loss reduction coupled with a clear understanding of the trade‑off between loss and adapter management cost—provides a solid foundation for future research and for engineers building adaptable, modular software ecosystems.