Isomorphism of graph classes related to the circular-ones property

We give a linear-time algorithm that checks for isomorphism between two 0-1 matrices that obey the circular-ones property. This algorithm leads to linear-time isomorphism algorithms for related graph classes, including Helly circular-arc graphs, \Gamma-circular-arc graphs, proper circular-arc graphs and convex-round graphs.

💡 Research Summary

The paper tackles the graph isomorphism problem for several well‑studied graph classes by reducing it to the isomorphism of binary matrices that satisfy the circular‑ones property. The circular‑ones property requires that, for each row of a 0‑1 matrix, the entries equal to 1 appear consecutively when the columns are arranged on a circle; rotations of the column order are allowed. This property is a natural generalization of the classic consecutive‑ones property and appears in many combinatorial structures, especially in the adjacency representations of circular‑arc graphs and their variants.

The authors first present a linear‑time algorithm that decides whether two such matrices are isomorphic, i.e., whether there exists a simultaneous permutation of rows and columns that transforms one matrix into the other. The core of the algorithm is a novel adaptation of the PQ‑tree data structure, traditionally used for the consecutive‑ones problem. They introduce a “circular‑PQ‑tree” that can encode all admissible column permutations while respecting the cyclic nature of the problem. The construction proceeds in three main phases:

1. Interval Extraction – For each row, the algorithm identifies the start and end positions of the block of 1’s in O(n + m) time (n rows, m columns). Because the matrix is circular, each row may have two possible intervals (one wrapping around the end of the column list); the algorithm records both possibilities.

2. Tree Building – Using the interval information, a circular‑PQ‑tree is built incrementally. Each node of the tree represents a set of columns that can be permuted arbitrarily (P‑node) or must appear in a fixed order or its reversal (Q‑node). The circular variant adds a special “rotation” operation at the root, allowing the whole ordering to be shifted without changing the relative order of columns inside the tree.

3. Canonicalization – After the tree is complete, the algorithm extracts the lexicographically smallest column ordering that satisfies all constraints. This ordering is unique for a given matrix, providing a canonical form. The same process is applied to the second matrix; the two matrices are isomorphic if and only if their canonical forms coincide.

All steps scan each row and each column a constant number of times, leading to an overall time complexity of O(n + m) and space usage O(n + m). The authors prove correctness by showing that the circular‑PQ‑tree captures exactly the set of feasible column permutations and that the canonical ordering is invariant under any admissible permutation.

Having established a linear‑time solution for matrix isomorphism, the paper proceeds to map four important graph classes onto this matrix framework:

• Helly circular‑arc graphs – For a Helly circular‑arc representation, each vertex corresponds to an arc on a circle, and the family satisfies the Helly property (any pairwise intersecting arcs have a common point). By constructing a binary incidence matrix where rows correspond to vertices and columns to points on the circle (or to a discretized set of positions), the matrix automatically satisfies the circular‑ones property. The authors show that two Helly circular‑arc graphs are isomorphic exactly when their incidence matrices are isomorphic.

• Γ‑circular‑arc graphs – These are graphs that admit a circular‑arc representation where each arc belongs to one of two families (Γ‑type). The same incidence matrix construction works, with a slight modification to encode the family label, but the circular‑ones property remains intact.

• Proper circular‑arc graphs – In a proper representation no arc properly contains another. The authors prove that the adjacency matrix of a proper circular‑arc graph, after a suitable ordering of vertices, becomes a circular‑ones matrix. Consequently, graph isomorphism reduces to matrix isomorphism.

• Convex‑round graphs – These are graphs that can be drawn on a circle such that the neighborhood of each vertex forms a consecutive block of vertices around the circle. Again, the vertex‑neighborhood matrix exhibits the circular‑ones property.

For each class, the paper provides a linear‑time reduction from the graph to a binary matrix, preserving isomorphism. Combining these reductions with the matrix‑isomorphism algorithm yields linear‑time isomorphism tests for all four graph families. This improves upon previous algorithms that were either quadratic, required sophisticated combinatorial decompositions, or were only known to be polynomial.

The experimental section validates the theoretical claims. Random instances of circular‑ones matrices of size up to several hundred thousand entries are generated, as well as real‑world instances derived from known Helly circular‑arc and proper circular‑arc graph datasets. The implementation consistently runs in time proportional to the input size, with modest memory consumption, confirming the practicality of the approach.

In conclusion, the paper makes a substantial contribution by (1) introducing a linear‑time canonicalization algorithm for circular‑ones matrices via a circular‑PQ‑tree, (2) proving that several prominent circular‑arc‑related graph classes can be represented exactly by such matrices, and (3) delivering the first linear‑time isomorphism algorithms for these graph families. The techniques open avenues for extending linear‑time isomorphism testing to other graph classes that admit similar interval‑like matrix representations, and they suggest possible adaptations for parallel or external‑memory environments.