[Paper Review] Solving Tree Containment Problem for Reticulation-visible Networks with Optimal Running Time

Andreas D. M. Gunawan|arXiv (Cornell University)|Feb 14, 2017

Genomics and Phylogenetic Studies6 references4 citations

TL;DR

This paper presents a linear-time algorithm for the Tree Containment Problem (TCP) in binary reticulation-visible networks, leveraging structural properties of stable nodes and a novel decomposition strategy to achieve optimal efficiency. By exploiting the visibility condition and processing subnetworks in a bottom-up manner, the method reduces time complexity from previous quadratic bounds to O(n), where n is the number of leaves.

ABSTRACT

Tree containment problem is a fundamental problem in phylogenetic study, as it is used to verify a network model. It asks whether a given network contain a subtree that resembles a binary tree. The problem is NP-complete in general, even in the class of binary network. Recently, it was proven to be solvable in cubic time, and later in quadratic time for the class of general reticulation visible networks. In this paper, we further improve the time complexity into linear time.

Motivation & Objective

• To address the computational inefficiency of the Tree Containment Problem (TCP) in phylogenetic networks, which is NP-complete in general.
• To improve upon prior quadratic-time algorithms for reticulation-visible networks by achieving optimal linear-time complexity.
• To develop a practical and efficient algorithm for verifying whether a given binary tree is displayed within a reticulation-visible network.
• To generalize the approach to other network classes by identifying structural properties that enable efficient computation.

Proposed method

• The algorithm uses a decomposition strategy based on the visibility property, focusing on lowest components in the network that can be collapsed into single leaves.
• It applies three specialized dissolution procedures—Dissolve_C1, Dissolve_C2, and Dissolve_C3—each tailored to different structural configurations of subnetworks.
• For each component, the algorithm checks subtree isomorphism using a linear-time comparison of binary trees, leveraging pre-processing and efficient traversal techniques.
• The method performs a bottom-up traversal of the network, starting from leaves and progressing toward the root, ensuring each subnetwork is processed only once.
• It uses breadth-first and post-order traversals to identify and contract components, maintaining correctness through stable ancestor properties.
• The algorithm maintains a compact representation of subnetworks and uses label set inclusion checks to early terminate non-matching cases.

Experimental results

Research questions

• RQ1 Can the Tree Containment Problem for reticulation-visible networks be solved in linear time?
• RQ2 What structural properties of reticulation-visible networks can be exploited to achieve optimal time complexity?
• RQ3 How can the decomposition of subnetworks be performed efficiently to support linear-time processing?
• RQ4 Is the proposed algorithm extendable to broader classes of phylogenetic networks beyond reticulation-visible ones?

Key findings

• The proposed algorithm solves the Tree Containment Problem in O(n) time for binary reticulation-visible networks, where n is the number of leaves.
• The time complexity is optimal, as it matches the lower bound implied by the size of the input network.
• The algorithm achieves this by exploiting the structural simplicity of lowest components in reticulation-visible networks, particularly those rooted at stable nodes.
• The decomposition and dissolution procedures (Dissolve_C1, Dissolve_C2, Dissolve_C3) each run in linear time relative to the size of the subnetwork they process.
• The overall TCPSolver algorithm runs in O(|V(N)|) time, which is linear in the number of nodes, due to the O(n) bound on network size for reticulation-visible networks.
• The method is generalizable to other network classes as long as nodes with similar structural properties exist.