CAMUS: scalable phylogenetic network estimation

Abstract

Motivation

Phylogenetic networks are models of evolution that go beyond trees, and so represent reticulate events such as horizontal gene transfer or hybridization, which are frequently found in many taxa. Yet, the estimation of phylogenetic networks is extremely computationally challenging, and nearly all methods are limited to very small datasets with perhaps 10–15 species (some limited to even smaller numbers).

Results

We introduce Constrained Algorithm Maximizing qUartetS (CAMUS), a scalable method for phylogenetic network estimation. CAMUS takes an input rooted constraint tree T as well as a set Q of unrooted quartet trees and returns a level-1 phylogenetic network N that is built upon T through the addition of edges, in order to maximize the number of quartet trees in Q that are induced in N. We perform a simulation study under the Network Multi-Species Coalescent and show that a simple pipeline using CAMUS provides high accuracy and outstanding speed and scalability, in comparison to two leading methods, PhyloNet-MPL used with a fixed tree and SNaQ. CAMUS is slightly less accurate than PhyloNet-MPL used without a fixed tree, but is much faster (minutes instead of hours) and can complete on inputs with 201 species while PhyloNet-MPL fails to complete on the inputs with more than 51 species.

Availability and implementation

The source code is available at https://github.com/jsdoublel/camus.

1 Introduction

Phylogenetic trees form an important basis for biological discovery, including understanding adaptation and biodiversity. The estimation of phylogenetic trees for a single gene can be fairly simple, but estimations of phylogenetic trees for multiple genes (i.e. species trees), and especially for genome-scale data, is complicated by processes, such as incomplete lineage sorting (ILS) and gene duplication and loss (GDL), in which different genomic regions (“genes”) have different trees (Maddison 1997). Much progress has been made on estimating species trees and new methods capable of high accuracy are now available [e.g. ASTRAL (Mirarab et al. 2014) is commonly used to estimate species trees in the presence of ILS]. However, when processes such as hybrid speciation or horizontal gene transfer occur, the tree model is no longer appropriate, and instead a phylogenetic network is needed (Huson and Bryant 2006, Mirarab et al. 2021, Kong et al. 2025).

Several methods have been developed for estimating phylogenetic networks, which differ by approach, the evolutionary processes they consider, and the constraints they make on the network topology. For example, Gusfield (2005) examined a population-genetics context where each site evolves down a rooted tree contained within the rooted phylogenetic network under the infinite sites assumption with HGT but not ILS (Gusfield 2005, Warnow et al. 2025). Other researchers have addressed phylogenetic network estimation under the Network Multi-Species Coalescent (NMSC) [see discussion in Mirarab et al. (2021)], which models both HGT and ILS.

Methods for estimating phylogenetic networks are challenged by statistical and computational issues. Specifically, when phylogenetic networks can have cycles that share vertices, Gambette and Huber (2012) showed that two different networks can have the same rooted triplet trees. In contrast, rooted phylogenetic networks in which no two cycles share nodes and all cycles are large enough are uniquely defined by their rooted triplets (Gambette and Huber 2012). For this reason, a substantial focus has been made on developing methods for estimating phylogenetic networks where the cycles are vertex-disjoint, which are referred to as level-1 phylogenetic networks or “galled trees” [see Gusfield (2005) for an early paper on level-1 phylogenetic network estimation].

Methods for estimating level-1 phylogenetic networks from gene trees under the NMSC have been developed, several of which are provably statistically consistent provided that there are no small cycles [e.g. various tools within the PhyloNet package (Than et al. 2008), SNaQ (Solís-Lemus and Ané 2016), and NANUQ+ (Allman et al. 2019)]. Of these, PhyloNet-MPL (Yu and Nakhleh 2015) and SNaQ, both of which optimize maximum pseudolikelihood, are probably the most frequently used tools, and have been shown to be able to run on datasets with at least 10 species. However, even these methods typically have very large computational requirements.

An alternative approach to phylogenetic network estimation operates in two-phases: first a rooted tree is computed, and then edges are added to the tree to create a phylogenetic network (e.g. Makarenkov 2001, Cao et al. 2019). While such approaches may fail to provide a guarantee of statistical consistency (see Ané et al. 2024), they can be fast and highly scalable. The approach we present here falls into this category of technique.

We present Constrained Algorithm Maximizing qUartetS (CAMUS). CAMUS takes as input a rooted binary tree T, which we refer to as a “constraint tree,” and a multiset $\mathcal{Q}$ of quartet trees, and then adds reticulate edges to T to produce a level-1 phylogenetic network that satisfies as many quartet trees from $\mathcal{Q}$ as possible (this is formally defined below). We present pipelines using CAMUS for level-1 phylogenetic network estimation from sequence data or gene trees. For example, when estimating a phylogenetic network under the NMSC, the input is a set of estimated gene trees. Given this input, in the first step we compute a rooted species tree T and also a multiset $\mathcal{Q}$ of quartet trees (i.e. unrooted trees on four species). Then, CAMUS adds edges to T, producing a rooted level-1 phylogenetic network that maximizes the number of quartet trees in $\mathcal{Q}$ induced by rooted trees within the network. CAMUS uses a dynamic programming approach that solves the optimization problem exactly in polynomial time.

We present the results of a study comparing CAMUS to SNaQ and PhyloNet-MPL on both simulated and biological data. Our study shows that CAMUS has some advantages over these methods, especially in terms of scalability to datasets with many species.

2 CAMUS

2.1 Preliminary material

Definition 1.

Each rooted binary level-1 phylogenetic network N induces a set $\mathcal{T}$of rooted binary trees formed by deleting one incoming edge into each reticulation node (i.e. nodes that have indegree 2) in each of the possible ways. Thus, N can be constructed by taking one of the trees $t\in \mathcal{T}$and adding reticulations (edges) to t. For this reason, N is said to be tree-based, and we may also say that $\mathbf{N}$is built on$\mathbf{t}$or that $\mathbf{N}$is an extension of$\mathbf{t}$. Given tree $t\in \mathcal{T}$, we consider t in its unrooted form and define the set $\mathbf{Q}(\mathbf{t})$of (unrooted) quartet trees induced in t. We note that quartet trees are also referred to more simply as quartets. A resolved quartet tree on four leaves $u,v,x,y$has an internal edge that separates the four leaves into two sets, such as $u,v$separated from$x,y$, and is denoted by $\mathbf{uv}|\mathbf{xy}$. We define $\mathbf{Q}({\mathbf{N}}_{\mathbf{r}})=\underset{\mathbf{t}\in \mathcal{T}}{\cup }\mathbf{Q}(\mathbf{t})$; the use of the subscript r indicates its reliance on the rooting of N.

Given a multiset $\mathcal{Q}$of quartets, a rooted binary phylogenetic tree T, and level-1 phylogenetic network N built upon T, we say that $q\in \mathcal{Q}$is satisfied by$\mathbf{N}$if $q\in Q(N_r)\setminus Q(T)$. We define $\mathbf{T}+\mathbf{e}$, where e is a non-tree edge in N, to be the subnetwork of N defined by removing all other non-tree edges and then suppressing nodes that have indegree and outdegree one. Furthermore, if $N=T+e$then we also say $\mathbf{q}$is satisfied by$\mathbf{e}$. These concepts are illustrated in Fig. 1.

Figure 1.

Tree-based phylogenetic network N with underlying tree T defined by solid (black) edges and one non-tree dashed edge (red). N can be constructed by adding the non-tree edge to T, and we say that the non-tree edge is “above the ordered pair $(u,w)$,” which means that the edges above u and w are subdivided, creating two new nodes (here denoted by $u^{\prime }$ and $w^{\prime }$), and a directed edge is then inserted from $u^{\prime }$ to $w^{\prime }$. N has a single cycle, which we denote by ${\gamma }_{(u,w)}$, which contains a unique node of indegree two. We also refer to this network as $T+e$, where e is the non-tree edge. N induces two rooted trees on$A,D,E,G$: the rooted tree $((A,D),(E,G))$ (which is also induced by T) and the rooted trees $(A,((D,E),G))$ (which does not appear in T). The rooted four-leaf trees define two unrooted trees on the leafset, referred to as quartet trees: $AD|EG$and$DE|AG$. We say that the quartet tree $DE|AG$ is satisfied by N but not by T, and we also say it is satisfied by the added edge from $u^{\prime }$ to $v^{\prime }$.

Lemma 1.

For any rooted binary tree T and extension of T into level-1 phylogenetic network N, if quartet tree q is satisfied by N, then there is a unique non-tree edge e such that q is satisfied by $T+e$. Thus, the set of quartets that are satisfied by N is the disjoint union of quartets satisfied by $T+e$, as we let e vary among the non-tree edges of N.

This lemma follows directly from Observation 2 in Warnow et al. (2025). Note that $T+e$ contains the endpoints of edge e, but these endpoints are not in T; instead, these are added to T by subdividing the relevant edges (see Fig. 1). We use this observation in the following:

Definition 2.

Procedure ASSIGN Given N, T, and quartet q satisfied by N and not by T, find $(u^{\prime },w^{\prime })$, the unique non-tree (directed) edge that satisfies q. Find u and w in T directly below $u^{\prime }$ and $w^{\prime }$, respectively, and let $v=lc{a}_T(u,w)$, where lca denotes the least common ancestor. Assign q and the non-tree edge $(u^{\prime },w^{\prime })$ satisfying q to the triplet $(u,w,v)$. Denote v as the “target” of q and its satisfying non-tree edge. Figure 1 illustrates Procedure ASSIGN, with the red non-tree edge and quartet $DE|AG$ both assigned to the triplet $(u,w,v)$.

Lemma 2.

Let N be a level-1 phylogenetic network N extending T, and let v be a node in T. Then there is at most one non-tree edge in N for which v is the target.

Proof.

If there were two non-tree edges in N with v the target, then N would contain two cycles, and it is easy to see that each would contain v as a node, and hence the two cycles would not be disjoint. This violates N being level-1. ▪

Definition 3.

Let T be a rooted tree and u and w be nodes in N. The phrase add edge above$(\mathbf{u},\mathbf{w})$ means we create two new vertices in T—one bisecting the edge above u and one bisecting the edge above w—then creating an edge from the vertex above u to the vertex above w (see Fig. 1). This creates a network N that has a cycle, denoted by $\mathit{\gamma }(\mathbf{u},\mathbf{w})$, for which the vertex created above w will be the bottom node of the cycle (i.e. the only node in the cycle with indegree 2).

Definition 4.

Let T be a rooted tree, let q be a quartet tree, and let $\mathcal{Q}$ be a multiset of quartet trees. We define ${\mathit{\delta }}_{\mathbf{T}}(\mathbf{q},(\mathbf{u},\mathbf{w}))$ to be the number of times q appears in $\mathcal{Q}$ if q is satisfied by an edge e added above $\left(u,w\right)$; otherwise, the value is 0.

Definition 5.

Let N be a rooted level-1 phylogenetic network and v a node in N. Then $\mathbf{l}(\mathbf{v})$ refers to the left child of v and $\mathbf{r}(\mathbf{v})$ refers to the right child of v.

2.2 The DP formulation

The input to CAMUS is a rooted binary tree T and a multiset $\mathcal{Q}$ of quartet trees, and CAMUS seeks to add edges to N to create a level-1 network that has the maximum “score,” where $\text{score}(T,\mathcal{Q})$, the “score of N,” is the number of quartet trees in $\mathcal{Q}$ that also appear in $Q(N_r)$.

The high-level approach in CAMUS is that we process the constraint tree T from the leaves upward, filling out a dynamic programming (DP) array M that has entries for every node v in T, so that M[v] is equal to the largest number of quartets in $\mathcal{Q}$ that can be satisfied by a level-1 phylogenetic network produced by adding edges that have target nodes in $T_v$. Once this array is filled in, the solution is obtained at the root r, and backtracking allow us to infer the optimal network. Thus, M[r] is the score of the best level-1 network possible built on T.

Consider the following quantity:

$$s_e(u,w)=\sum _{q\in \mathcal{Q}}{\delta }_T(q,(u,w)),$$ (1)

which is the number of quartets in $\mathcal{Q}$ satisfied by the edge e added above $(u,w)$ (see Definition 4). Because, in a level-1 phylogenetic network N, each quartet that is satisfied by N will be satisfied by exactly one added edge (Lemma 1), it follows that M[v] will be the maximum sum of $s_e(u,w)$, as $(u,w)$ ranges over a set of added edges whose target nodes are in $T_v$ where the set together defines a level-1 phylogenetic network. We therefore calculate all these variable $s_e(.)$ in a preprocessing step, as they do not depend on other calculations.

We now present the DP algorithm. The base case is simply that $M[v]=0$ for all v where v is a leaf. Next, we fill out the dynamic programming matrix from the bottom up:

$$M[v]=\max \{\begin{array}{c}M[l(v)]+M[r(v)],\hfill \\ s(v)\hfill \end{array},$$ (2)

where $s(v)$ (formally defined below) represents the case where the optimal solution is achieved by adding an edge whose target node is v (see Definition 2). Note that the first part of the assignment, where $M[v]=M[l(v)]+M[r(v)]$, handles the case where the optimal score is obtained without adding any edge whose target node is v.

We now define $s(v)$. We begin by defining $\mathit{Pairs}(v)$, a set of ordered pair $(u,w)$ of nodes in T so that the triplet $(u,w,v)$ would be assigned to a non-tree edge we would add to T (see Procedure ASSIGN given in Definition 2). This definition depends on whether v is the root r of T or not, as we cannot add an edge to T that begins above the root of T. Therefore, when $v\ne r$, we let $\mathit{Pairs}(v)$ denote the set of all ordered pairs of nodes $(u,w)$ in T such that $lc{a}_T(u,w)=v$; note that this allows $u=v$ with w below v, and so includes pairs of the form $(v,w)$ with w below v. These pairs $(v,w)$ with w below v imply a ghost lineage (Tricou et al. 2025), which is the result of incomplete taxon sampling. When $v=r$, we define $\mathit{Pairs}(v)$ to be the set of all ordered pairs $(u,w)$ in T where $lc{a}_T(u,w)=r$ but neither u nor w is r. Then,

$$s(v)=\underset{(u,w)\in \hspace{0.17em}\mathit{Pairs}(v)}{\max }\left(s_e(u,w)+s_{dp}(v,u,w)\right),$$ (3)

We now show how we calculate $s_{dp}(v,u,w)$. Recall that $lc{a}_T(u,w)=v$ and the assumption is that we are adding the edge e above $(u,w)$ and hence v is the target node. Consider the cycle ${\gamma }_{(u,w)}$ formed by adding the edge e. Since a level-1 phylogenetic network N cannot have a pair of cycles that share vertices, this means that the target node x for any other edge that is added cannot be in this cycle (see Definition 2); otherwise x would be in two cycles, contradicting that N is level-1. We use this to derive the formula for $s_{dp}(v,u,w)$, but note that it depends on whether $v=u$ (as this changes the cycle). If $v\ne u$, we obtain:

$$\begin{array}{c}{s}_{dp}(v,u,w)=M[w]+M[u]+\hfill \\ \sum _{x\in {\gamma }_{(u,w)}\cap V(T)\setminus \left\{v\right\}}\{\begin{array}{cc}M[l(x)]\hfill & \text{if} l(x)\cancel{\in }{\gamma }_{(u,w)} \hfill \\ M[r(x)]\hfill & \text{otherwise}\hfill \end{array}.\hfill \end{array}$$ (4)

When $v=u$, we obtain:

$$\begin{array}{c}{s}_{dp}(v,u,w)=M[w]+\hfill \\ \sum _{x\in {\gamma }_{(u,w)}\cap V(T)}\{\begin{array}{cc}M[l(x)]\hfill & \text{if} l(x)\cancel{\in }{\gamma }_{(u,w)}\hfill \\ M[r(x)]\hfill & \text{otherwise}\hfill \end{array}.\hfill \end{array}$$ (5)

Equations 4 and 5 sum the subproblem scores for all the subnetworks hanging off of ${\gamma }_{(u,w)}$.

Proof of correctness

Theorem 1.

The algorithm gives an assignment of non-tree edges to add to the tree T that maximizes the number of quartets in $\mathcal{Q}$that are satisfied, under the constraint that we create a level-1 phylogenetic network.

Proof.

By design, the solution that CAMUS outputs is a level-1 phylogenetic network N that extends T. Specifically, consider the target nodes for a pair of added edges defined by the backtracking through the DP matrix. If their target nodes are not in relation (neither above the other), then the cycles they create are vertex-disjoint. If some target node x is above another target node y, then this case would be handled by Equations (4) and (5), which ensure that the created cycles do not share vertices. It is also easy to see that M[r] is the number of quartet trees in $\mathcal{Q}$ that are satisfied by N and not by T, where r is the root of T.

Hence, it remains to be shown that the score of the network found by CAMUS is the largest possible score of any level-1 phylogenetic network that extends T. We will prove that for each node x in T, M[x] is the best score that can be found for any level-1 phylogenetic network all of whose added edges have target nodes in $T_x$. We prove this by strong induction on the size of the leafset below x. Our base case is where the size of the leafset is 1, which is when x is a leaf; for this case, the score is 0, and is trivially correct. The inductive hypothesis is that M[x] is correctly computed for all nodes x that have fewer than k leaves in their subtree, and we now consider a node y with k leaves in its subtree.

Let N be an optimal extension of $T_y$ to a level-1 phylogenetic network. If this optimal extension does not include any added edge with target node y, then by the inductive hypothesis, its total score is easily seen to be $M[l(y)]+M[r(y)]$, where $l(y)$ and $r(y)$ are the left and right children of y, respectively.

If the optimal extension includes an added edge e with target node y, then e is added above the pair $(a,b)$, where $lc{a}_T(a,b)=y$. We will show that in this case, the score of the optimal extension is given by $s(y)$, thus establishing correctness.

By Lemma 1, each $s_e(a,b)$ does not depend on another calculations, and hence is correctly computed during the preprocessing. Additionally, due to Lemma 2, we see that it is sufficient to simply search for one edge that maximizes $s(y)$; we do not need to consider the possibility of multiple edges with a target of y. Also note that for the $s_{dp}(y,a,b)$ term, $T_y+e$ has a cycle, and since N is level-1, all the other cycles in N are disjoint from this cycle, which means that the target nodes for all other non-tree edges in N are not in the cycle. Therefore, for every other cycle, its target node is below some node in the cycle, and its contribution to the score is handled by $s_{dp}$, given in Equations 4 or 5. Finally, we note that, due to Lemma 1, it is not possible that any quartets are double-counted when summing up the terms in $s(y)$ or $s_{dp}(y,a,b)$.

Thus, the score of the optimal extension of $T_y$ is identical with how M[y] is defined, as given in Equation (2), and the inductive hypothesis holds. ▪

2.3 Computational complexity

We report the big-O running time and memory usage for CAMUS as a function of the size of its input (a rooted tree T with n species and a multiset $\mathcal{Q}$ of quartet trees). Note that $\mathcal{Q}$ can be equivalently represented as a weighted set, where the weight of an element is the number of times the element appears in $\mathcal{Q}$, and thus $\left|\mathcal{Q}\right|$ represents the total number of unique quartet topologies.

First, we consider the time to compute ${\delta }_T(q,(u,w))$. We perform preprocessing in order to enable constant time LCA queries of all pairs of vertices, the leafsets for all vertices, and the depth of every node in the tree. After this preprocessing, we can calculate ${\delta }_T(q,(u,w))$ for a single triplet $q,u,w$ in $O(1)$ time (since determining which quartets are induced can be determined by the nodes they attach to in the cycle [see discussion in Warnow et al. (2025) and Gambette et al. (2012)]). The preprocessing can be computed in $O(n^2)$ time. Given this, the time to solve $s(v)$ is $O(n^2(\left|\mathcal{Q}\right|+n))$. There are $O(n)$ subproblems that need to be solved, thus making the total naively $O(n^3(\left|\mathcal{Q}\right|+n))$; however, this analysis overestimates the running time as no edge is ever considered in the $s(·)$ function more than once over all subproblems. Therefore, the total number of edges maximized over across all subproblems is $O(n^2)$, making the runtime $O(n^2(\left|\mathcal{Q}\right|+n))$.

We can represent $\mathcal{Q}$ in $O(n^4)$ space, since we consider integers to require $O(1)$ memory. All other data structures needed for the algorithm, such as the precomputed LCAs, etc., can be stored in $O(n^2)$; hence the total memory usage is $O(n^4)$.

2.4 Reticulation restriction

By design, the score (the number of quartets in $\mathcal{Q}$ that are satisfied) will never decrease as the number of reticulations increases, and so the objective is to find the “right” number of reticulations. This is a general challenge in phylogenetic network estimation, that we address through an extension of CAMUS. Specifically, we introduce a modification to the dynamic programming algorithm in order to retrieve a set of phylogenetic networks, differing by the number of reticulations. Given the set of phylogenetic networks, one for each number of added edges, it then becomes possible to select a suitable number of edges by examining where the score stops improving substantially. We demonstrate this in Fig. 2, which shows that on the 16-taxon datasets, in general selecting the network with just one reticulation (i.e. one extra edge) seems best.

Figure 2.

Impact of the number of computed reticulations in the CAMUS network and two error measures on 16-taxon datasets. Top: percentage of unsatisfied quartet trees from the input multiset $\mathcal{Q}$. Bottom: phylogenetic reconstruction error as a function of number of reticulations. Based on the improvement in optimization score, one reticulation would be selected, which also corresponds to the most topologically accurate solution for this input.

To this end, we introduce a modification to the algorithm with the following properties. Given a constraint tree T and a set of quartets $\mathcal{Q}$, the modification returns m networks $N_1,N_2,\dots ,N_m$ so that:

• All networks are level-1.

• All networks contain the constraint tree T.

• $N_k$ for $1\le k\le m$ contains exactly k non-tree edges.

• All networks maximize the number of quartets from $\mathcal{Q}$ they contain, subject to the above constraints.

This can be accomplished by a relatively simple modification of the dynamic programming algorithm. Instead of having the dynamic programming lookup table only have n entries (where n is the number of taxa), we make it a matrix that has n rows and m columns, where m is the number of reticulations after which the score does not improve. However, it is known that a level-1 phylogenetic network on n leaves will not have more than $n-1$ reticulations, so $m\le n-1$ is guaranteed. The subproblem $M[v,k]$ represents the solution found for subtree $T_v$ of the network limited to allowing k non-tree edges, and we solve each subproblem in order of increasing k, dynamically adding new columns to our matrix, until we no longer get an improvement in score.

Thus, we need to solve each of the n original subproblems $O(m)$ times. It takes $O(m^2)$ time to find the correct DP look-ups to solve each problem optimally, thus the running time of the overall algorithm goes from $O(n^2(\left|\mathcal{Q}\right|+n))$ to $O(n^2(\left|\mathcal{Q}\right|+m^{3}n))$. However, in our experiments $m\ll n$ and the running time is dominated by the $O(n^2|\mathcal{Q}|)$ term so there is very little running time overhead in practice.

3 Pipelines using CAMUS

CAMUS can be used with any rooted constraint tree T and multiset $\mathcal{Q}$ of quartet trees, and the way that each is estimated from the data depends on assumptions about the process and the type of data. We present two pipelines here: one for use with SNPs that evolve down phylogenetic networks under a homoplasy-free model described in Gusfield (2005) and Warnow et al. (2025) and the other for use with gene trees that evolve down phylogenetic networks under the NMSC.

Both pipelines take advantage of ASTRAL, by using it to compute a tree T that is then treated as the constraint tree, after which CAMUS is run to add reticulations. Therefore we begin by describing ASTRAL.

3.1 ASTRAL

The input to ASTRAL is a set $\mathcal{G}$ of unrooted gene trees that are leaf-labeled by a set S of taxa (typically but not necessarily species). Recall that every gene tree t that has leaves labeled in S defines a set $Q(t)$ of quartet trees. Let $\mathcal{Q}(\mathcal{G})$ denote the multiset of quartet trees obtained from the different gene trees, and let $w(q)$ denote the number of times quartet q appears in $\mathcal{Q}(\mathcal{G})$. ASTRAL uses dynamic programming to find an optimal solution to the following problem:

• Input: $\mathcal{G}$ of unrooted gene trees with leaves taken from S

• Output: unrooted tree T that maximizes $\mathit{score}(T)=\sum _{q\in Q(T)}w(q)$.

We refer to $\mathit{score}(T)$ as the “quartet support score of T.” As established in Mirarab et al. (2014), ASTRAL is statistically consistent at estimating the unrooted topology of the species tree when gene trees evolve under the multi-species coalescent (MSC). Note also that although ASTRAL returns an unrooted tree, if the input includes an outgroup, then the output species tree can be rooted on the edge leading to the outgroup.

3.2 Pipelines for use with SNPs under Gusfield’s model

Gusfield’s model addresses a population-genetics context where the sites have two states and evolve under the infinite sites assumption, which means that they change state only once during their evolution within the phylogenetic network. While the term “SNP” refers more generally to a site that exhibits two states, the use of the term SNP in Gusfield et al. (2004) and Gusfield (2005) specifically required that the site evolves under this infinite sites model and so would be homoplasy-free. Gusfield proposed a method to construct the rooted level-1 phylogenetic network from such sites, provided that the network does not have small cycles (Gusfield 2005). His approach was proven correct when the set of sites covers all the edges in the network and each site changes exactly once in Warnow et al. (2025). In addition, Warnow et al. (2025) described a model of evolution in which sites evolve without homoplasy down trees contained within the level-1 network. The model has numeric parameters (e.g. probabilities of change on the edges and probabilities of inheriting a state using each reticulation edge) that can be used to define probabilities of site patterns at the leaves. Under this model, they established that Gusfield’s method and some other quartet-based methods are guaranteed statistically consistent (i.e. would return the true network with probability converging to 1 as the number of sites increased). Thus, these methods will produce perfect reconstructions of the network given enough error-free data with high probability. The main limitation with these methods is that when the data are either insufficient or have errors (i.e. evolve with homoplasy), then the methods will just fail to return a network.

We now show we can use CAMUS to address this limitation, provided we have an outgroup (which is typically the case). We are given an input alignment of SNPs, so there are n rows and k columns, each column representing a SNP.

1. We initialize the multiset $Q\leftarrow \varnothing$.

2. For every site that exhibits two states, we find all sets of four leaves $a,b,c,d$ where a and b exhibit one state and c and d exhibit the other state. We then add each such quartet tree $ab|cd$ to Q. (Note: a given quartet tree will be added only once for a given SNP, but more than one SNP can produce the same quartet tree.)

3. We run ASTRAL on $\mathcal{Q}$ to obtain the constraint tree T, thus treating each quartet tree as an input “gene tree.”

4. We use the outgroup species to root T.

5. We run CAMUS on the input pair (rooted version of T and multiset $\mathcal{Q}$).

Note that for all inputs, this pipeline will always return an output rooted level-1 phylogenetic network, since (i) ASTRAL always returns a tree, (ii) we have an outgroup and hence can root the tree returned by ASTRAL, and (iii) CAMUS always returns a level-1 network building on the given input tree. This addresses the major limitation of the prior approach, which is that it is only guaranteed to return an output when all sites are homoplasy-free and there are enough sites to recover the network perfectly.

We now ask whether there are conditions where this pipeline will recover N correctly. Recall that the network N is tree-based (which follows directly from being level-1). Furthermore, any tree $t\in Q(N_r)$ can be used as the basis for N (i.e. N can be obtained by adding reticulate edges to t). Now suppose that there is some $t\in Q(N_r)$, such that the most probable quartet tree is induced by t. We will show that under these conditions, this pipeline is a statistically consistent estimate of N.

Note that as the number of sites increases, for every four species, the most frequently observed quartet tree will be the most probable quartet tree with probability converging to 1, and so the quartet support score of t will be larger than the score of any other tree. When the quartet support score for t is larger than any other tree’s quartet support, ASTRAL will return t since it solves its optimization problem exactly. This tree will be rooted using the outgroup and then passed to CAMUS for the second stage. Therefore, as the number of sites increases, with probability converging to 1, the input to CAMUS will be a rooted tree t from $Q(N_r)$. According to the theory given in Warnow et al. (2025), as the number of gene trees increases, this multiset will be identical to $Q(N_r)$ (when considered as a set), with probability converging to 1. When $\mathcal{Q}$ is a multi-set version of $Q(N_r)$, then CAMUS will add the correct reticulations and return N, since this is the unique network that can satisfy all the quartets in $Q(N_r)$, and hence N will be the unique solution to CAMUS’ optimization problem.

3.3 Pipeline for use with gene trees under the NMSC

The input is a set $\mathcal{G}$ of estimated gene trees and the assumption is that the true gene trees evolve down a level-1 phylogenetic network under the NMSC model, which allows for both ILS and HGT. A simple approach for providing a rooted tree T and multiset $\mathcal{Q}$ is to let T be a tree $T^{*}$ computed by ASTRAL on the input gene trees, and let $\mathcal{Q}$ could be all quartet trees induced by any gene tree.

Unfortunately, there is no guarantee that the tree $T^{*}$ that ASTRAL produces will be in $\mathcal{T}$; moreover, no current method is known that is provably statistically consistent for this problem (Ané et al. 2024). Although ASTRAL can be provably inaccurate at estimating an underlying tree within the network under some conditions (Solís-Lemus et al. 2016, Ané et al. 2024, Dinh and Baños 2025), some simulation studies have shown it can be highly accurate and also scalable for estimating the underlying tree under a random HGT model (Davidson et al. 2015). This observation is supported by theory that shows that when HGT is random and not too frequent, that quartet-based methods, such as ASTRAL, are statistically consistent at estimating the underlying species tree (Roch and Snir 2013).

Given an estimate T of an underlying tree, the next step is to estimate $\mathcal{Q}$ from the input data. If we assume that the true phylogenetic network N is level-1 and that $T^{*}$ is one of the underlying trees, then gene trees can differ from $T^{*}$ due to both ILS and HGT. In this case, the quartet tree distribution can then be examined to see what additional insight they provide into whether reticulate edges are also needed. Our approach is to take the distribution on quartet trees, and decide whether for a given set of four species, the distribution is suggestive of an ILS-only scenario. If so, then we would just keep the most frequently observed quartet tree, and otherwise we would keep the top two most frequent quartet trees. The motivation for this approach is that we do not want to include quartet trees that are not in $Q(N_r)$. On the other hand, we do not want to eliminate these quartet trees.

In an extreme case, there may be little to no HGT, which would be indicated by finding that the distribution on quartet trees defined by the gene trees fits the multi-species coalescent (MSC) model (Takahata 1989) under which, for every four species, the most probable quartet tree matches the species tree and the other two quartet trees have the same lower probability. Thus, to the extent that for a set of four species, we get a pattern that matches the MSC, we might decide to not include any quartet tree in $\mathcal{Q}$ beyond the most frequently observed quartet tree. We use this idea in designing a simple method for filtering the set ${\mathcal{Q}}_0$ of $(\begin{array}{c}n\\ 4\end{array})$ quartet trees to a smaller set that seems reflective of HGT rather than only ILS.

3.4 Quartet filtering

Given a threshold $t\in [0,1]$, we filter the set ${\mathcal{Q}}_0$ of all possible quartet trees as follows. For a given set of four species $a,b,c,d$ and quartet topologies $q_1,q_2,$ and $q_3$, we let $f_i$ denote the relative frequency of $q_i$ (i.e. proportion of genes exhibiting of $q_i$), and we assume without loss of generality that $1\ge f_1\ge f_2\ge f_3\ge 0$. We always keep the most frequently observed quartet tree $q_1$ and we do not include $q_3$. However, we also include $q_2$ if the gap between $f_2$ and $f_3$ is large enough, as we define in Quartet Filtering, given in Algorithm 1. In the end, we return the set of quartet trees, denoted by $\mathcal{K}$.

Algorithm 1 Quartet Filtering. The input is a multiset of quartet trees on four species, and the output is a multiset, including the copies of the most frequently observed quartet tree or the copies of the top two most frequent. This is applied to all sets of four species to determine the multiset $\mathcal{Q}$ given as input to CAMUS. Require:$f_1\ge f_2\ge f_3$;  $t\in [0,1]$

 $\mathcal{Q}\leftarrow \left\{q_1\right\}$

 if$f_2-f_3>t·\left(f_2+f_3\right)$then 

  $\mathcal{Q}\leftarrow \mathcal{Q}\cup \left\{q_2\right\}$

 end if 

 return$\mathcal{Q}$

Now, consider the case where the true evolutionary history is tree-like (i.e. does not require any additional edges) so that the gene trees evolve down the tree under the MSC, which allows for ILS but not HGT. In this case, for large numbers of gene trees, we expect the distribution on quartet tree topologies to be close to the expected values under the MSC, which is $f_1>f_2=f_3$. For finite numbers of gene trees, we would not expect $f_2=f_3$, but as the number of genes increases, the gap between $f_2$ and $f_3$ will approach 0.

We use a simple technique for building $\mathcal{Q}$: we always include $q_1$ but we decide whether to include $q_2$ in the set $\mathcal{Q}$ as follows: if $f_2-f_3>t·(f_2+f_3)$, then we include $q_2$ and otherwise do not. Note that for t small enough (specifically, $t<\frac{f_2-f_3}{f_2+f_3}$), then we will include $q_2$. We formalize this in the Quartet Filtering algorithm in Algorithm 1.Note the impact of t on Quartet Filtering. How we set t determines which quartet trees are used to find edges to add to T. Even if T is an induced tree in the true network N, if we let t be too small, we may include many quartet trees, which could produce a network that is more complex than the true network; in contrast, if we let t be too large, then we may not include enough quartet trees, which would produce a network that is less complex than the true network. Therefore, in Experiment 1, we used algorithm design data (separate from the testing data used in Experiments 2 and 3) to pick a default value for t, and then used that value in Experiments 2 and 3.

In total, the pipeline takes as input a set $\mathcal{G}$ of estimated gene trees and an outgroup species, and has the following steps:

1. Estimate a species tree T and root it on the edge leading to the outgroup (default: use ASTRAL).

2. Extract all the induced quartet trees from the gene trees, keeping only those quartet trees that are fully resolved, thus producing a multiset $\mathcal{Q}$.

3. Modify $\mathcal{Q}$ by filtering, using the selected threshold t.

4. Apply CAMUS to the pair $(T,\mathcal{Q}).$

We note that the specific choices (e.g. the technique used to estimate the species tree, the threshold t, and even the technique used to estimate the gene trees, which could involve collapsing low support edges, as has been explored in other settings) will depend on the application and dataset.

4 Experimental study

We evaluated the second pipeline using CAMUS in comparison to other methods for estimating level-1 phylogenetic networks with respect to topological accuracy and computational performance on synthetic datasets that evolve down level-1 phylogenetic networks under the NMSC; this enables an evaluation of accuracy, since the true phylogenetic network on a biological dataset is not known with certainty. We also include an analysis of the avian phylogenomics dataset of roughly 50 birds and 14 000 gene trees studied in Jarvis et al. (2014).

4.1 Methods

We compared CAMUS to SNaQ (v1.1) and PhyloNet-MPL (v3.8.2) (Yu and Nakhleh 2015), two leading methods for phylogenetic network estimation that also take as input a set of estimated gene trees and return level-1 phylogenetic networks. The choice of PhyloNet-MPL and SNaQ is based on their frequency of use in biological dataset analyses and that they are able to complete on datasets with at least 10 species.

We gave the same set of estimated gene trees to each method as well as the same tree T, which was treated either as a constraint tree (for one way of running PhyloNet-MPL) or just as a starting tree (for SNaQ and the other way of running PhyloNet-MPL). The trees T were computed using ASTRAL (v1.23.4.6) on the estimated gene trees.

While SNaQ takes as input unrooted gene trees, PhyloNet-MPL requires rooted gene trees; we enable this through the use of the outgroup species in each dataset. While SNaQ always allows the input tree to change, PhyloNet-MPL can be run in two ways: allowing the tree to change or considering it fixed throughout the search. We refer to the second way of running PhyloNet-MPL as “PhyloNet-MPL(FT),” where “FT” stands for “Fixed Tree.”

4.2 Synthetic datasets

We generated simulated datasets with 1000 gene trees that evolve down level-1 phylogenetic networks. The datasets used in the Algorithm Design (Experiment 1) are disjoint from the datasets used to compare CAMUS to PhyloNet-MPL and SNaQ in Experiments 2 and 3. These datasets range from 16 species to 201 species, and each dataset has an outgroup.

To produce our simulated datasets, we use SiPhyNetwork (v1.1.0) (Justison et al. 2023) to create a simulated true phylogenetic network. These networks are then filtered to ensure that they are level-1, and an outgroup taxon was added, so that the rooting can be determined in later steps; the resulting 16- to 51-taxon networks had 1 or 2 reticulations, and the larger networks had up to 6 reticulations (Fig. 1, available as supplementary data at Bioinformatics online). After that, we used PhyloCoalSimulations (v1.0.0) (Fogg et al. 2023) to evolve true gene trees under the NMSC; thus, these gene trees have discordance from both Incomplete Lineage Sorting (ILS) as well as HGT events. To produce estimated gene trees, we then evolved DNA sequences of length 500 down the trees with INDELible (v1.03) (Fletcher and Yang 2009) under GTRGAMMA, and estimated trees with IQ-TREE 3 (v 3.0.1) (Wong et al. 2025) (for the 16–26 taxon datasets) and FastTree 2 (v2.1.11) (Price et al. 2010) (for the 26–201 taxon datasets). This results in gene trees with an average estimation error of 21% in the case of IQ-TREE and 21% in the case of FastTree 2 (Table 2, available as supplementary data at Bioinformatics online). We used Ultrafast Bootstrap Approximation with IQTREE (Hoang et al. 2018) in order to estimate branch support. Our method requires a constraint tree for estimation, and PhyloNet-MPL and SNaQ can be assisted by a starting network (or tree), thus we estimated this tree with ASTRAL 4 (Mirarab et al. 2014, Zhang et al. 2025) using the estimated gene trees. More details about the parameters and exact commands used for all of the above are provided in the Supplementary Materials, available as supplementary data at Bioinformatics online.

4.3 Computational environment

We ran all methods with a time limit of 12 h and a memory limit of 256 GB on the University of Illinois Urbana-Champaign Campus Cluster. Each analysis had access to 32 cores.

4.4 Evaluating topological error

To assess phylogenetic network topology estimation error, we use the cluster metric from PhyloNet’s CmpNets command (Nakhleh and Wang 2005), which calculates a false positive and false negative rate based on soft-wired clusters (i.e. the clades of trees in $\mathcal{T}$, see Definition 1). We were able to use this code on networks with up to 51 species but not larger, due to computational limitations (i.e. more than 5 h to score a single 51-species network). Therefore we calculate this error rate only for the networks with at most 51 species.

4.5 Experiments

Our evaluations are split into three experiments on synthetic datasets, and one experiment on a biological dataset:

• Experiment 1. Designing the pipeline for phylogenetic network estimation from gene trees using CAMUS; this involves setting the default value for threshold t in Quartet Filtering that we then use in subsequent experiments.

• Experiment 2. Evaluating computational performance of CAMUS, PhyloNet-MPL, and SNaQ on datasets with 16 to 201 species.

• Experiment 3. Evaluating accuracy of CAMUS, PhyloNet-MPL, and SNaQ on datasets with 16 to 51 species.

• Experiment 4. Evaluating CAMUS and PhyloNet-MPL on the avian phylogenomic dataset of Jarvis et al. (2014).

For Experiments 1–3, we show results on 20 replicates containing 1000 gene trees each. Experiment 1 uses a different set of replicates on 26 taxa than Experiments 2 and 3.

4.6 Evaluation for experiments 1–3

We evaluated runtime and topological error for SNaQ, PhyloNet-MPL, PhyloNet-MPL(FT), and CAMUS, each given the ASTRAL tree as either a constraint tree [for PhyloNet-MPL(FT) and CAMUS] or as a starting tree (for SNaQ and PhyloNet-MPL). In addition, each method was used to create a level-1 phylogenetic network with exactly one reticulation; while it is possible that allowing more reticulations would improve accuracy, selecting the correct number of reticulations is non-trivial from a statistical viewpoint and often performed using a visual inspection such as provided in Fig. 2. Furthermore, it would require running SNaQ, PhyloNet-MPL, and PhyloNet-MPL multiple times (for each possible number of reticulations), which is computationally infeasible for these methods (unlike CAMUS, which automatically returns networks with a range of number of reticulations in its default setting, using the Reticulation Restriction modification).

5 Results

5.1 Experiment 1

Recall that when we estimate the phylogenetic network from gene trees, we construct a multiset $\mathcal{Q}$ of quartet trees that will contain some but generally not all the quartet trees found in the input gene trees. The selection of which quartets to include is described above in the section labeled “Quartet Filtering,” whose output depends on a parameter t. In Experiment 1, we assessed the impact of t on the final accuracy of the estimated level-1 phylogenetic network. All results are shown on 20 replicates of the 26-taxon dataset (25 taxa plus 1 outgroup taxon) with 1000 estimated gene trees.

As seen in Fig. 2, available as supplementary data at Bioinformatics online, applying a threshold $t>0$ (i.e. not including all possible quartet trees) improved accuracy, and that $t=0.5$ provided the best accuracy of the tested thresholds. Henceforth, we used $t=0.5$ for all further experiments.

5.2 Experiment 2

In this experiment, we explored computational performance for the different methods we selected. We examined several different numbers of taxa, between 16 and 201, each with 1000 estimated gene trees, across 20 replicates. In this experiment, CAMUS was run using the Reticulation Restriction mode, where it computes the best network for all numbers of added non-tree edges (up to when the score stops improving), while the other methods were run only long enough to find the best network with one non-tree edge.

As seen in Fig. 3 (left), all methods except CAMUS failed at some point to complete within our time limit of 12 h, before reaching the largest dataset on 201 taxa. SNaQ was only able to run on our smallest number of species, failing on 26 taxa; PhyloNet-MPL is a bit faster, but timed out on 51 taxa; and PhyloNet-MPL(FT) managed to run on 51 taxa, but could not complete on the 101-taxon dataset. Moreover, the running time for CAMUS on 16-species datasets was under a second, and increased with the number of species but was still under a minute when analyzing 51-species datasets. CAMUS ran in roughly 20 minutes for 101 species, and completed on datasets with 201 species in just 2–3 h.

Figure 3.

Computational performance of methods as a function of the number of species given 1000 estimated gene trees. Left: running time; right: peak memory usage. Methods do not appear if they do not complete within 12 h.

We also looked at the memory usage for the methods [Fig. 3 (right)]. Memory usage was relatively low for all methods on the datasets with at most 51 species, and CAMUS used less memory than the other methods on these datasets. However, the memory usage of CAMUS increased with the number of species, reaching 156 GB for 201 species (a condition the other methods could not analyze within the allowed time). This increase in memory usage is unsurprising, as CAMUS memory usage scales linearly with the number of quartets (i.e. $O(n^4)$).

5.3 Experiment 3

Here, we evaluated all methods on the testing datasets for topological accuracy. All methods completed within 12 h on 16 species [Fig. 4 (left)], and overall SNaQ had the worst accuracy, while PhyloNet-MPL without a fixed tree was the most accurate. CAMUS was slightly less accurate than PhyloNet-MPL without a fixed tree, and was more accurate than PhyloNet-MPL(FT).

Figure 4.

Phylogenetic network estimation error. We show error rates (false negative and false positive) for SNaQ, PhyloNet-MPL, PhyloNet-MPL(FT), and CAMUS on simulated datasets. Left: 16-species datasets; middle: 26-species datasets; right: 51-species datasets. Each condition has 1000 estimated gene trees and 20 replicates. Results not shown for a particular number of species indicate the method failed to complete within the allotted time (12 h) given 256 GB of memory. Each phylogenetic network estimation method creates a level-1 phylogenetic network with one reticulation, and uses the ASTRAL tree either as a constraint tree or as a starting tree (this is true for all experiments in this study).

On 26 species [Fig. 4 (middle)], SNaQ could not complete within the allowed time, but the remaining methods did complete. On these datasets, again PhyloNet-MPL without a fixed tree had the best accuracy, followed by CAMUS, and then by PhyloNet-MPL(FT).

Finally, on 51 species [Fig. 4 (right)], only CAMUS and PhyloNet-MPL(FT) completed within the allowed time and CAMUS had much better accuracy than PhyloNet-MPL(FT).

5.4 Experiment 4

We analyzed the dataset of Jarvis et al. (2014) of 48 birds (Table 3, available as supplementary data at Bioinformatics online) and $\sim$14 000 estimated gene trees, with a non-avian outgroup. We computed an ASTRAL tree on the gene trees provided in Jarvis et al. (2015). To calculate $\mathcal{Q}$, we first collapsed gene tree branches with support less than 75% and then applied the default threshold $t=0.5$. CAMUS completed in just over a minute; comparisons of the score for different numbers of reticulations indicated that setting the number of reticulations to one or two were both reasonable choices for this dataset (Fig. 3, available as supplementary data at Bioinformatics online). The level-1 CAMUS phylogenetic network with two hybridizations (Fig. 5) shows support for two potential hybridization events in avian history, a topic of significant interest [e.g. Stiller et al. (2024)]. Other ASTRAL networks showed similar trends (Figs 4–7, available as supplementary data at Bioinformatics online).

Figure 5.

Avian phylogenetic network with two reticulations returned by CAMUS on the Jarvis et al. (2014) dataset with $\sim$14 000 gene trees. This is based on the ASTRAL constraint tree computed using the estimated gene trees available at Jarvis et al. (2015) with CAMUS then applied using $t=0.5$ and with edges in gene trees with support below $75\%$ collapsed for the computation of $\mathcal{Q}$. The locations of the hybridizations may be relevant to questions raised in Stiller et al. (2024) about hybridizations in avian evolution.

Using the same ASTRAL constraint tree as input, PhyloNet-MPL without a fixed tree was unable to complete within 24 h (the time limit we imposed); PhyloNet-MPL(FT) was able to complete but used up to 3 h for a single network when allowed 2 reticulations. PhyloNet-MPL(FT) networks show different trends than the CAMUS networks (Figs 8 and 9, available as supplementary data at Bioinformatics online). For additional results and details, see the Supplementary Materials, available as supplementary data at Bioinformatics online.

6 Conclusion

We have presented CAMUS, a polynomial time method that takes as input a rooted binary tree T and a multiset $\mathcal{Q}$ of quartet trees, and returns a level-1 phylogenetic network that satisfies as many of these quartet trees in $\mathcal{Q}$ as possible. CAMUS can be used within pipelines to estimate phylogenetic networks, and we described two such pipelines (one for Gusfield’s model, which is relevant to population genetics, and the other for estimating phylogenetic networks from gene trees under the NMSC). These pipelines differ, and demonstrate the flexibility of CAMUS, where the tree T and set $\mathcal{Q}$ can be defined as suited for the input dataset and model of evolution. Thus, CAMUS is a flexible tool for use within pipelines for phylogenetic network estimation, which will allow it to be used in new pipelines with ease.

Our simulation study explored CAMUS specifically for estimating level-1 phylogenetic networks under the NMSC, where the input is a set of estimated gene trees. We showed that CAMUS has much greater speed and scalability than PhyloNet-MPL (used with or without a fixed tree) and SNaQ. CAMUS was superior in accuracy to SNaQ and PhyloNet-MPL used with a fixed tree, but was slightly less accurate than PhyloNet-MPL used without a fixed tree. Furthermore, CAMUS successfully completes on datasets with 201 species and 1000 gene trees, while none of the other methods was able to complete within 12 h on the dataset with 101 species. Furthermore, the most accurate method, PhyloNet-MPL used without a constraint tree, fails to complete on the inputs we studied with more than 26 species.

We also used CAMUS to explore the hypothesis that hybridization was present in the avian phylogeny, using a number of different treatments for a dataset of 48 birds and $\sim$14 000 gene trees. This study showed support for this hypothesis, and demonstrated that CAMUS can be used efficiently for data exploration in large genomic datasets. Thus, CAMUS is a practical tool for accurate phylogenetic network estimation, scaling to at least 201 species.

This study suggests several directions for future research, but due to space limitations, we mention only a few. Given the improvement in accuracy for PhyloNet-MPL when it allows the input tree to change, using CAMUS within a heuristic search to allow it to explore different constraint trees could improve accuracy. Furthermore, we have started to explore the impact on accuracy of collapsing low support edges in the gene trees, and our initial investigations on a limited sample suggest that this improves accuracy. This study compared methods in terms of accuracy after adding a single reticulations, but future work should explore accuracy when adding two or more reticulations, especially when used with a statistical test to determine when to stop adding reticulations. This simulation study focused on a fixed number of genes and level of gene tree estimation error, and only varied the number of species; a more extensive study should be performed that also varies other parameters, such as the gene tree estimation error, number of gene trees, number of reticulations in the model network, etc. Future work should also compare CAMUS to other methods, such as NANUQ+ (Allman et al. 2019), Squirrel (Holtgrefe et al. 2025), and TriMouNet (Mao and Grünewald 2026).

Conflict of interests

None declared.

Funding

This work was supported in part by the United States National Science Foundation grant 2316233 to TW.

Author Contributions

James Willson (Conceptualization, Formal Analysis, Investigation, Software, Visualization, Writing—original draft), and Tandy Warnow (Conceptualization, Formal Analysis, Funding Acquisition, Writing—review & editing)

Data availability

CAMUS is available at https://github.com/jsdoublel/camus. The scripts used for this study are available at https://gist.github.com/jsdoublel. All the data generated for this study are freely available at Willson and Warnow (2026). CAMUS utilizes Gotree (Lemoine and Gascuel 2021) as a core dependency.