Simultaneous Interval Graphs

In a recent paper, we introduced the simultaneous representation problem (defined for any graph class C) and studied the problem for chordal, comparability and permutation graphs. For interval graphs, the problem is defined as follows. Two interval graphs G_1 and G_2, sharing some vertices I (and the corresponding induced edges), are said to be `simultaneous interval graphs’ if there exist interval representations R_1 and R_2 of G_1 and G_2, such that any vertex of I is mapped to the same interval in both R_1 and R_2. Equivalently, G_1 and G_2 are simultaneous interval graphs if there exist edges E’ between G_1-I and G_2-I such that G_1 \cup G_2 \cup E’ is an interval graph. Simultaneous representation problems are related to simultaneous planar embeddings, and have applications in any situation where it is desirable to consistently represent two related graphs, for example: interval graphs capturing overlaps of DNA fragments of two similar organisms; or graphs connected in time, where one is an updated version of the other. In this paper we give an O(n^2*logn) time algorithm for recognizing simultaneous interval graphs,where n = |G_1 \cup G_2|. This result complements the polynomial time algorithms for recognizing probe interval graphs and provides an efficient algorithm for the interval graph sandwich problem for the special case where the set of optional edges induce a complete bipartite graph.

💡 Research Summary

The paper introduces and solves the recognition problem for simultaneous interval graphs, a natural extension of the classic interval‑graph recognition task to a pair of graphs that share a set of vertices. Two interval graphs G₁ and G₂ are called simultaneous if there exist interval representations R₁ and R₂ such that every vertex belonging to the common vertex set I receives exactly the same interval in both representations. Equivalently, one may ask whether there exists a set of “optional” edges E′ connecting the exclusive parts of the two graphs (i.e., between G₁−I and G₂−I) such that the union G₁ ∪ G₂ ∪ E′ is itself an interval graph. This formulation mirrors the interval‑graph sandwich problem, but with the additional restriction that the optional edges form a complete bipartite graph between the two exclusive vertex parts.

The authors first place the problem in context. While the general interval‑graph sandwich problem is NP‑complete, the special case of probe interval graphs—where optional edges are allowed only between a distinguished probe set and the remaining vertices—admits a polynomial‑time algorithm. The simultaneous‑interval‑graph problem occupies an intermediate niche: the optional edges are unrestricted between the two exclusive parts, yet they still form a bipartite complete graph. This structure enables the design of an efficient algorithm that would be unlikely for the fully general case.

The core of the algorithm relies on two classic tools from interval‑graph theory: the clique tree (also known as the interval tree) and the PQ‑tree. Every interval graph can be represented by a tree whose nodes correspond to maximal cliques, and the tree’s structure encodes the consecutive‑ones property of the graph’s adjacency matrix. PQ‑trees compactly represent all permutations of a set that satisfy a collection of consecutive‑ones constraints. By constructing clique trees for G₁ and G₂ separately, the algorithm identifies how the common vertices I appear in each tree. Because I must be represented by identical intervals in both representations, the algorithm fixes the relative order of the cliques containing I in both trees.

Next, the algorithm merges the two PQ‑trees while preserving the fixed order of I‑cliques. During this merge, it examines each pair (u, v) with u ∈ G₁−I and v ∈ G₂−I. The complete bipartite nature of the optional edges means that the algorithm can decide, for each such pair, whether to include the edge (u, v) in E′. This decision is guided by the conflict intervals that arise when the PQ‑tree constraints of the two graphs clash. If adding (u, v) resolves a conflict without violating the consecutive‑ones property, the edge is added; otherwise it is omitted. Because each conflict can be detected and resolved in constant time per pair, the total work for handling all possible edges is O(|G₁−I|·|G₂−I|) = O(n²).

The algorithm’s steps can be summarized as follows:

1. Build the maximal‑clique trees for G₁ and G₂ in O(n log n) time.
2. Construct PQ‑trees for the two graphs, encoding the consecutive‑ones constraints of their adjacency matrices.
3. Fix the ordering of cliques that contain the common vertices I, thereby synchronizing the two representations.
4. Merge the PQ‑trees, detecting conflict intervals and deciding, for each potential edge between the exclusive parts, whether to insert it into E′.
5. Verify that the resulting merged structure satisfies the consecutive‑ones property; if it does, the original pair of graphs is simultaneous interval, otherwise it is not.

The overall time complexity is O(n²·log n). The log factor stems from the need to maintain balanced PQ‑trees during repeated merges and from sorting operations required when constructing the initial clique trees. Memory consumption stays within O(n²), dominated by the implicit representation of the bipartite optional edge set.

Beyond the theoretical contribution, the paper highlights several practical motivations. In comparative genomics, intervals often model DNA fragments; two related species can be represented by two interval graphs that share a subset of fragments. Simultaneous representations guarantee that homologous fragments occupy the same genomic interval in both species, facilitating direct visual comparison. Similarly, in dynamic networks where vertices and edges evolve over time, one may wish to keep the interval layout of persistent vertices unchanged while allowing new vertices to be added; the simultaneous‑interval‑graph framework provides exactly this guarantee.

The authors also discuss connections to existing work. Their algorithm can be viewed as a refinement of the probe‑interval‑graph algorithm: instead of a single probe set, there are two exclusive parts, and the optional edges are complete between them. Consequently, the result can be interpreted as an efficient solution to a restricted interval‑graph sandwich problem where the optional edges induce a complete bipartite graph. This bridges the gap between the tractable probe case and the intractable general case, offering a new tractable subclass.

In the concluding section, the paper outlines future directions. Extending the approach to more general optional‑edge structures (e.g., arbitrary bipartite graphs, or multiple shared vertex sets) remains open. Another promising line is the minimum‑edge addition variant: given G₁ and G₂, find the smallest set E′ that makes the union an interval graph while respecting the simultaneous constraint. Finally, experimental validation on real biological datasets and evolving network logs would demonstrate the practical impact of the algorithm.

In summary, the paper delivers a rigorous, polynomial‑time algorithm for recognizing simultaneous interval graphs, achieving O(n²·log n) runtime. By leveraging clique‑tree and PQ‑tree techniques, it resolves the simultaneous representation problem for the important special case where optional edges form a complete bipartite graph, thereby enriching both the theoretical landscape of interval‑graph algorithms and their applicability to real‑world problems.