diff --git a/README.md b/README.md
index 2305921..9d91904 100644
--- a/README.md
+++ b/README.md
@@ -21,10 +21,10 @@ with open('sample_data/toy_trees.p', 'rb') as fh:
 	ete_trees = pickle.load(fh)
 
 dag = hdag.history_dag_from_etes(ete_trees, ['sequence'])
-dag.count_trees()  # 1041
+dag.count_histories()  # 1041
 
-dag.add_all_allowed_edges()
-dag.count_trees()  # 3431531
+dag.make_complete()
+dag.count_histories()  # 3431531
 
 dag.hamming_parsimony_count()  # Shows counts of trees of different parsimony scores
 dag.trim_optimal_weight()
@@ -59,7 +59,7 @@ trees = [tree for tree in dag]
 
 # Another method for fetching all trees in the dag is provided, but the order
 # will not match index order:
-scrambled_trees = list(dag.get_trees())
+scrambled_trees = list(dag.get_histories())
 
 
 # Union is implemented as dag merging, including with sequences of dags
@@ -74,7 +74,7 @@ newdag = dag[0] | (dag[i] for i in range(3,5))
     * `history_dag_from_newicks`
     * `history_dag_from_etes`
 * Trees can be extracted from the history DAG with methods like
-    * `HistoryDag.get_trees`
+    * `HistoryDag.get_histories`
     * `HistoryDag.sample`
     * `HistoryDag.to_ete`
     * `HistoryDag.to_newick` and `HistoryDag.to_newicks`
diff --git a/docs/quickstart.rst b/docs/quickstart.rst
index 30058ac..d02b115 100644
--- a/docs/quickstart.rst
+++ b/docs/quickstart.rst
@@ -11,15 +11,16 @@ A history DAG is a way to represent a collection of trees whose nodes
 sequence.
 
 In its simplest form, a history DAG may represent a single tree. To construct
-such a history DAG from a tree, we annotate each node in the tree with its child clades.
-The **clade** beneath a tree node is the set of leaf node labels
+such a history DAG from a tree, we annotate each node in the tree with its
+child clades.  The **clade** beneath a tree node is the set of leaf node labels
 reachable from that node, or the set containing the node's own label if it is
-itself a leaf. The **child clades** of a node are the set of clades
-beneath that node's children.
+itself a leaf. We also refer to this set as a node's **clade union**, since it
+is the union of the node's child clades. The **child clades** of a node are the
+set of clades beneath that node's children.
 
 After annotating each node with its child clades, a **UA (universal ancestor)
 node** is added as a parent of the original tree's root node. The resulting
-structure is an example of a history DAG which we call a **clade tree**:
+structure is an example of a history DAG which we call a **history**:
 
 |pic1| -> |pic2|
 
@@ -35,13 +36,13 @@ parent node associated to an edge, must be the same as the clade below the
 child node that the edge targets.
 
 After converting multiple trees with the same set of leaf labels to clade
-trees, those clade trees can be unioned to create a history DAG that represents
+trees, those histories can be unioned to create a history DAG that represents
 at least those trees used to create it. Any structure in the resulting history
 DAG which contains the UA node and all leaves, and has exactly one edge for
-each node-child clade pair, is a clade tree. Clade trees represent labeled
+each node-child clade pair, is a history. Histories represent labeled
 trees by the inverse of the correspondence introduced above:
 
-For example, the clade tree highlighted in red in this image:
+For example, the history highlighted in red in this image:
 
 .. image:: figures/history_dag_example.svg
    :width: 100%
@@ -105,7 +106,7 @@ Now, we will create a history DAG using the ``sequence`` attribute as the data
 for node labels:
 
 >>> dag = hdag.history_dag_from_etes(ete_trees, ['sequence'])
->>> dag.count_trees()
+>>> dag.count_histories()
 1041
 >>> dag.count_topologies()
 389
@@ -132,9 +133,9 @@ of ``explode_nodes``).
 We can find even more new trees by adding all edges which connect
 nodes whose child clades are compatible:
 
->>> dag.add_all_allowed_edges()
+>>> dag.make_complete()
 1048
->>> dag.count_trees()
+>>> dag.count_histories()
 3431531
 
 After such edge additions, all the trees in the DAG are no longer guaranteed to
@@ -191,7 +192,7 @@ Now we can trim to only the trees with 48 unique node labels:
 
 >>> dag.trim_optimal_weight(** node_count_funcs, optimal_func=min)
 
-Finally, we can sample a single clade tree from the history DAG, and make it an
+Finally, we can sample a single history from the history DAG, and make it an
 ete tree for further rendering/processing:
 
 >>> t = dag.sample().to_ete()
@@ -208,7 +209,7 @@ index-order:
 Another method for fetching all trees in the dag is provided, but the order
 will not match index order:
 
->>> scrambled_trees = list(dag.get_trees())
+>>> scrambled_trees = list(dag.get_histories())
 
 
 History DAGs can be merged using the :meth:`historydag.HistoryDag.merge`
diff --git a/historydag/__init__.py b/historydag/__init__.py
index 4eb01f3..ff2df5f 100644
--- a/historydag/__init__.py
+++ b/historydag/__init__.py
@@ -6,7 +6,7 @@
     from_newick,
     history_dag_from_newicks,
     history_dag_from_etes,
-    history_dag_from_clade_trees,
+    history_dag_from_histories,
 )
 
 from . import _version
diff --git a/historydag/dag.py b/historydag/dag.py
index e065b5a..70a3608 100644
--- a/historydag/dag.py
+++ b/historydag/dag.py
@@ -28,13 +28,13 @@
 from historydag.counterops import counter_sum, counter_prod
 
 
-def _under_clade_dict(nodeseq: Sequence["HistoryDagNode"]) -> Dict:
+def _clade_union_dict(nodeseq: Sequence["HistoryDagNode"]) -> Dict:
     clade_dict: Dict[FrozenSet[Label], List[HistoryDagNode]] = {}
     for node in nodeseq:
-        under_clade = node.under_clade()
-        if under_clade not in clade_dict:
-            clade_dict[under_clade] = []
-        clade_dict[node.under_clade()].append(node)
+        clade_union = node.clade_union()
+        if clade_union not in clade_dict:
+            clade_dict[clade_union] = []
+        clade_dict[node.clade_union()].append(node)
     return clade_dict
 
 
@@ -68,28 +68,31 @@ def __repr__(self) -> str:
         return str((self.label, set(self.clades.keys())))
 
     def __hash__(self) -> int:
-        return hash((self.label, self.partitions()))
+        return hash((self.label, self.child_clades()))
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, HistoryDagNode):
-            return (self.label, self.partitions()) == (other.label, other.partitions())
+            return (self.label, self.child_clades()) == (
+                other.label,
+                other.child_clades(),
+            )
         else:
             raise NotImplementedError
 
     def __le__(self, other: object) -> bool:
         if isinstance(other, HistoryDagNode):
-            return (self.label, self.sorted_partitions()) <= (
+            return (self.label, self.sorted_child_clades()) <= (
                 other.label,
-                other.sorted_partitions(),
+                other.sorted_child_clades(),
             )
         else:
             raise NotImplementedError
 
     def __lt__(self, other: object) -> bool:
         if isinstance(other, HistoryDagNode):
-            return (self.label, self.sorted_partitions()) < (
+            return (self.label, self.sorted_child_clades()) < (
                 other.label,
-                other.sorted_partitions(),
+                other.sorted_child_clades(),
             )
         else:
             raise NotImplementedError
@@ -100,39 +103,60 @@ def __gt__(self, other: object) -> bool:
     def __ge__(self, other: object) -> bool:
         return not self.__lt__(other)
 
-    def node_self(self) -> "HistoryDagNode":
-        """Returns a HistoryDagNode object with the same clades and label, but
-        no descendant edges."""
+    def empty_copy(self) -> "HistoryDagNode":
+        """Returns a HistoryDagNode object with the same clades, label, and
+        attr dictionary, but no descendant edges."""
         return HistoryDagNode(
             self.label, {clade: EdgeSet() for clade in self.clades}, deepcopy(self.attr)
         )
 
-    def under_clade(self) -> FrozenSet[Label]:
-        r"""Returns the union of this node's child clades"""
+    def node_self(self) -> "HistoryDagNode":
+        """Deprecated name for :meth:`empty_copy`"""
+        return self.empty_copy()
+
+    def clade_union(self) -> FrozenSet[Label]:
+        r"""Returns the union of this node's child clades
+        (or a set containing only the node label, for leaf nodes.)"""
         if self.is_leaf():
             return frozenset([self.label])
         else:
             return frozenset().union(*self.clades.keys())
 
+    def under_clade(self) -> FrozenSet[Label]:
+        """Deprecated name for :meth:`clade_union`"""
+        return self.clade_union()
+
     def is_leaf(self) -> bool:
         """Returns whether this is a leaf node."""
         return not bool(self.clades)
 
-    def is_root(self) -> bool:
-        """Returns whether this is a DAG root node, or UA (universal ancestor)
-        node."""
+    def is_ua_node(self) -> bool:
+        """Returns whether this is the source node in the DAG, from which all
+        others are reachable."""
         return False
 
-    def partitions(self) -> frozenset:
+    def is_root(self) -> bool:
+        """Deprecated name for :meth:`is_ua_node`"""
+        return self.is_ua_node()
+
+    def child_clades(self) -> frozenset:
         """Returns the node's child clades, or a frozenset containing a
         frozenset if this node is a UANode."""
         return frozenset(self.clades.keys())
 
-    def sorted_partitions(self) -> tuple:
+    def partitions(self) -> frozenset:
+        """Deprecated name for :meth:`child_clades`"""
+        return self.child_clades()
+
+    def sorted_child_clades(self) -> tuple:
         """Returns the node's child clades as a sorted tuple containing leaf
         labels in sorted tuples."""
         return tuple(sorted([tuple(sorted(clade)) for clade in self.clades.keys()]))
 
+    def sorted_partitions(self) -> tuple:
+        """Deprecated name for :meth:`sorted_child_clades`"""
+        return self.sorted_child_clades()
+
     def children(
         self, clade: Set[Label] = None
     ) -> Generator["HistoryDagNode", None, None]:
@@ -158,7 +182,7 @@ def add_edge(
     ) -> bool:
         r"""Adds edge, if allowed and not already present. Returns whether edge was added."""
         # target clades must union to a clade of self
-        key = frozenset() if self.is_root() else target.under_clade()
+        key = frozenset() if self.is_ua_node() else target.clade_union()
         if key not in self.clades:
             raise KeyError("Target clades' union is not a clade of this parent node: ")
         else:
@@ -170,12 +194,12 @@ def add_edge(
                 prob_norm=prob_norm,
             )
 
-    def _get_subtree_by_subid(self, subid: int) -> "HistoryDagNode":
+    def _get_subhistory_by_subid(self, subid: int) -> "HistoryDagNode":
         r"""Returns the subtree below the current HistoryDagNode corresponding to the given index"""
         if self.is_leaf():  # base case - the node is a leaf
             return self
         else:
-            history = self.node_self()
+            history = self.empty_copy()
 
             # get the subtree for each of the clades
             for clade, eset in self.clades.items():
@@ -192,7 +216,7 @@ def _get_subtree_by_subid(self, subid: int) -> "HistoryDagNode":
                     else:
                         # add this edge to the tree somehow
                         history.clades[clade].add_to_edgeset(
-                            child._get_subtree_by_subid(curr_index)
+                            child._get_subhistory_by_subid(curr_index)
                         )
                         break
 
@@ -201,7 +225,7 @@ def _get_subtree_by_subid(self, subid: int) -> "HistoryDagNode":
 
     def remove_edge_by_clade_and_id(self, target: "HistoryDagNode", clade: frozenset):
         key: frozenset
-        if self.is_root():
+        if self.is_ua_node():
             key = frozenset()
         else:
             key = clade
@@ -219,13 +243,13 @@ def remove_node(self, nodedict: Dict["HistoryDagNode", "HistoryDagNode"] = {}):
             if not child.parents:
                 child.remove_node(nodedict=nodedict)
         for parent in self.parents:
-            parent.remove_edge_by_clade_and_id(self, self.under_clade())
+            parent.remove_edge_by_clade_and_id(self, self.clade_union())
         self.removed = True
 
     def _sample(self, edge_selector=lambda n: True) -> "HistoryDagNode":
-        r"""Samples a clade tree (a sub-history DAG containing the root and all
+        r"""Samples a history (a sub-history DAG containing the root and all
         leaf nodes). Returns a new HistoryDagNode object."""
-        sample = self.node_self()
+        sample = self.empty_copy()
         for clade, eset in self.clades.items():
             mask = [edge_selector((self, target)) for target in eset.targets]
             sampled_target, target_weight = eset.sample(mask=mask)
@@ -239,7 +263,7 @@ def _sample(self, edge_selector=lambda n: True) -> "HistoryDagNode":
             )
         return sample
 
-    def _get_trees(self) -> Generator["HistoryDagNode", None, None]:
+    def _get_subhistories(self) -> Generator["HistoryDagNode", None, None]:
         r"""Return a generator to iterate through all trees expressed by the DAG."""
 
         def genexp_func(clade):
@@ -250,7 +274,7 @@ def f():
                 return (
                     (clade, targettree, i)
                     for i, target in enumerate(eset.targets)
-                    for targettree in target._get_trees()
+                    for targettree in target._get_subhistories()
                 )
 
             return f
@@ -259,7 +283,7 @@ def f():
 
         # TODO is this duplicated code?
         for option in utils.cartesian_product(optionlist):
-            tree = self.node_self()
+            tree = self.empty_copy()
             for clade, targettree, index in option:
                 tree.clades[clade].add_to_edgeset(
                     targettree,
@@ -286,7 +310,7 @@ def _newick_label(
             A string which can be used as a node name in a newick string.
             For example, `namefuncresult[&&NHX:feature1=val1:feature2=val2]`
         """
-        if self.is_root():
+        if self.is_ua_node():
             return self.label  # type: ignore
         else:
             if features is None:
@@ -315,14 +339,16 @@ def __init__(self, targetnodes: "EdgeSet"):
         for child in self.children():
             child.parents.add(self)
 
-    def node_self(self) -> "UANode":
+    def empty_copy(self) -> "UANode":
         """Returns a UANode object with the same clades and label, but no
         descendant edges."""
         newnode = UANode(EdgeSet())
         newnode.attr = deepcopy(self.attr)
         return newnode
 
-    def is_root(self):
+    def is_ua_node(self) -> bool:
+        """Returns whether this is the source node in the DAG, from which all
+        others are reachable."""
         return True
 
 
@@ -349,18 +375,18 @@ def __eq__(self, other: object) -> bool:
 
     def __getitem__(self, key) -> "HistoryDag":
         r"""Returns the sub-history below the current history dag corresponding to the given index."""
-        length = self.count_trees()
+        length = self.count_histories()
         if key < 0:
             key = length + key
         if isinstance(key, slice) or not type(key) == int:
             raise TypeError(f"History DAG indices must be integers, not {type(key)}")
         if not (key >= 0 and key < length):
             raise IndexError
-        self.count_trees()
-        return HistoryDag(self.dagroot._get_subtree_by_subid(key))
+        self.count_histories()
+        return HistoryDag(self.dagroot._get_subhistory_by_subid(key))
 
     def __len__(self) -> int:
-        return self.count_trees()
+        return self.count_histories()
 
     def __or__(self, other) -> "HistoryDag":
         newdag = self.copy()
@@ -405,10 +431,10 @@ def cladesets(node):
         for node in self.postorder():
             if node.label not in label_indices:
                 label_indices[node.label] = len(label_list)
-                label_list.append(None if node.is_root() else tuple(node.label))
+                label_list.append(None if node.is_ua_node() else tuple(node.label))
                 assert (
                     label_list[label_indices[node.label]] == node.label
-                    or node.is_root()
+                    or node.is_ua_node()
                 )
             node_list.append((label_indices[node.label], cladesets(node), node.attr))
             node_idx = len(node_list) - 1
@@ -480,11 +506,11 @@ def _check_valid(self) -> bool:
         # used in the traversal)
 
         for node in po:
-            if not node.is_root():
+            if not node.is_ua_node():
                 for clade, eset in node.clades.items():
                     for child in eset.targets:
                         # ***Parent clade equals child clade union for all edges:
-                        if child.under_clade() != clade:
+                        if child.clade_union() != clade:
                             raise ValueError(
                                 "Parent clade does not equal child clade union"
                             )
@@ -520,16 +546,23 @@ def _check_valid(self) -> bool:
     def serialize(self) -> bytes:
         return pickle.dumps(self.__getstate__())
 
-    def get_trees(self) -> Generator["HistoryDag", None, None]:
-        """Return a generator containing all trees in the history DAG.
+    def get_histories(self) -> Generator["HistoryDag", None, None]:
+        """Return a generator containing all internally labeled trees in the
+        history DAG.
 
-        The order of these trees does not necessarily match the order of
-        indexing. That is, ``dag.get_trees()`` and ``tree for tree in
-        dag`` will result in different orderings. ``get_trees`` should
+        Note that each history is a history DAG, containing a UA node.
+
+        The order of these histories does not necessarily match the order of
+        indexing. That is, ``dag.get_histories()`` and ``history for history in
+        dag`` will result in different orderings. ``get_histories`` should
         be slightly faster, but possibly more memory intensive.
         """
-        for cladetree in self.dagroot._get_trees():
-            yield HistoryDag(cladetree)
+        for history in self.dagroot._get_subhistories():
+            yield HistoryDag(history)
+
+    def get_trees(self) -> Generator["HistoryDag", None, None]:
+        """Deprecated name for :meth:`get_histories`"""
+        return self.get_histories()
 
     def get_leaves(self) -> Generator["HistoryDag", None, None]:
         """Return a generator containing all leaf nodes in the history DAG."""
@@ -537,7 +570,7 @@ def get_leaves(self) -> Generator["HistoryDag", None, None]:
 
     def num_nodes(self) -> int:
         """Return the number of nodes in the DAG, not counting the UA node."""
-        return sum(1 for _ in self.preorder(skip_root=True))
+        return sum(1 for _ in self.preorder(skip_ua_node=True))
 
     def num_leaves(self) -> int:
         """Return the number of leaf nodes in the DAG."""
@@ -650,11 +683,11 @@ def unlabel(self) -> "HistoryDag":
         that all histories in the DAG have unique topologies."""
 
         newdag = self.copy()
-        model_label = next(self.preorder(skip_root=True)).label
+        model_label = next(self.preorder(skip_ua_node=True)).label
         # initialize empty/default value for each item in model_label
         field_values = tuple(type(item)() for item in model_label)
         internal_label = type(model_label)(*field_values)
-        for node in newdag.preorder(skip_root=True):
+        for node in newdag.preorder(skip_ua_node=True):
             if not node.is_leaf():
                 node.label = internal_label
 
@@ -682,7 +715,7 @@ def remove_abundance_clade(old_clade):
             return frozenset(leaf_label_dict[old_label] for old_label in old_clade)
 
         def remove_abundance_node(old_node):
-            if old_node.is_root():
+            if old_node.is_ua_node():
                 return UANode(
                     EdgeSet(
                         [
@@ -710,8 +743,8 @@ def remove_abundance_node(old_node):
         newdag = newdag.sample() | newdag
         return newdag
 
-    def is_clade_tree(self) -> bool:
-        """Returns whether history DAG is a clade tree.
+    def is_history(self) -> bool:
+        """Returns whether history DAG is a history.
 
         That is, each node-clade pair has exactly one descendant edge.
         """
@@ -721,6 +754,10 @@ def is_clade_tree(self) -> bool:
                     return False
         return True
 
+    def is_clade_tree(self) -> bool:
+        """Deprecated name for :meth:`is_history`"""
+        return self.is_history()
+
     def copy(self) -> "HistoryDag":
         """Uses bytestring serialization, and is guaranteed to copy:
 
@@ -753,14 +790,18 @@ def merge(self, trees: Union["HistoryDag", Sequence["HistoryDag"]]):
                 if n in nodedict:
                     pnode = nodedict[n]
                 else:
-                    pnode = n.node_self()
+                    pnode = n.empty_copy()
                     nodedict[n] = pnode
 
                 for _, edgeset in n.clades.items():
                     for child, weight, _ in edgeset:
                         pnode.add_edge(nodedict[child], weight=weight)
 
-    def add_all_allowed_edges(
+    def add_all_allowed_edges(self, *args, **kwargs) -> int:
+        """Provided as a deprecated synonym for :meth:``make_complete``."""
+        return self.make_complete(*args, **kwargs)
+
+    def make_complete(
         self,
         new_from_root: bool = True,
         adjacent_labels: bool = True,
@@ -789,11 +830,11 @@ def add_all_allowed_edges(
                 for node in self.postorder()
             }
 
-        clade_dict = _under_clade_dict(self.preorder(skip_root=True))
-        clade_dict[self.dagroot.under_clade()] = []
+        clade_dict = _clade_union_dict(self.preorder(skip_ua_node=True))
+        clade_dict[self.dagroot.clade_union()] = []
 
         for node in self.postorder():
-            if new_from_root is False and node.is_root():
+            if new_from_root is False and node.is_ua_node():
                 continue
             else:
                 for clade in node.clades:
@@ -809,16 +850,16 @@ def add_all_allowed_edges(
                             n_added += node.add_edge(target)
         return n_added
 
-    @utils._cladetree_method
+    @utils._history_method
     def to_newick(
         self,
         name_func: Callable[[HistoryDagNode], str] = lambda n: "unnamed",
         features: Optional[List[str]] = None,
         feature_funcs: Mapping[str, Callable[[HistoryDagNode], str]] = {},
     ) -> str:
-        r"""Converts clade tree to extended newick format.
+        r"""Converts a history to extended newick format.
         Supports arbitrary node names and a
-        sequence feature. For use on a history DAG which is a clade tree.
+        sequence feature. For use on a history DAG which is a history.
 
         For extracting newick representations of trees in a general history DAG, see
         :meth:`HistoryDag.to_newicks`.
@@ -855,14 +896,14 @@ def newick(node):
 
         return newick(next(self.dagroot.children())) + ";"
 
-    @utils._cladetree_method
+    @utils._history_method
     def to_ete(
         self,
         name_func: Callable[[HistoryDagNode], str] = lambda n: "unnamed",
         features: Optional[List[str]] = None,
         feature_funcs: Mapping[str, Callable[[HistoryDagNode], str]] = {},
     ) -> ete3.TreeNode:
-        """Convert a history DAG which is a clade tree to an ete tree.
+        """Convert a history DAG which is a history to an ete tree.
 
         Args:
             name_func: A map from nodes to newick node names
@@ -893,7 +934,7 @@ def etenode(node: HistoryDagNode) -> ete3.TreeNode:
                 newnode.add_feature(feature, func(node))
             return newnode
 
-        nodedict = {node: etenode(node) for node in self.preorder(skip_root=True)}
+        nodedict = {node: etenode(node) for node in self.preorder(skip_ua_node=True)}
 
         for node in nodedict:
             for target in node.children():
@@ -906,7 +947,8 @@ def to_graphviz(
         self,
         labelfunc: Optional[Callable[[HistoryDagNode], str]] = None,
         namedict: Mapping[Label, str] = {},
-        show_partitions: bool = True,
+        show_child_clades: bool = True,
+        show_partitions: bool = None,
     ) -> gv.Digraph:
         r"""Converts history DAG to graphviz (dot format) Digraph object.
 
@@ -915,8 +957,11 @@ def to_graphviz(
                 their DAG node labels, or their label hash if label data is too large.
             namedict: A dictionary from node labels to label strings. Labelfunc will be
                 used instead, if both are provided.
-            show_partitions: Whether to include child clades in output.
+            show_child_clades: Whether to include child clades in output.
+            show_partitions: Deprecated alias for show_child_clades.
         """
+        if show_partitions is not None:
+            show_child_clades = show_partitions
 
         def labeller(label):
             if label in namedict:
@@ -936,7 +981,7 @@ def taxa(clade):
 
         G = gv.Digraph("labeled partition DAG", node_attr={"shape": "record"})
         for node in self.postorder():
-            if node.is_leaf() or show_partitions is False:
+            if node.is_leaf() or show_child_clades is False:
                 G.node(str(id(node)), f"<label> {labelfunc(node)}")
             else:
                 splits = "|".join(
@@ -951,7 +996,7 @@ def taxa(clade):
                     if weight > 0.0:
                         label += f"w:{weight}"
                     G.edge(
-                        f"{id(node)}:{taxa(clade) if show_partitions else 'label'}:s",
+                        f"{id(node)}:{taxa(clade) if show_child_clades else 'label'}:s",
                         f"{id(target)}:n",
                         label=label,
                     )
@@ -978,7 +1023,7 @@ def make_uniform(self):
         The probability assigned to each edge below a clade is
         proportional to the number of subtrees possible below that edge.
         """
-        self.count_trees()
+        self.count_histories()
         for node in self.postorder():
             for clade, eset in node.clades.items():
                 for i, target in enumerate(eset.targets):
@@ -1022,14 +1067,14 @@ def is_ambiguous(label):
         nodeorder = list(self.postorder())
         new_nodes = set()
         for node in nodeorder:
-            if not node.is_root() and is_ambiguous(node.label):
+            if not node.is_ua_node() and is_ambiguous(node.label):
                 if node.is_leaf():
                     raise ValueError(
                         "Passed expand_func would explode a leaf node. "
                         "Leaf nodes may not be exploded."
                     )
                 for resolution in expand_func(node.label):
-                    newnodetemp = node.node_self()
+                    newnodetemp = node.empty_copy()
                     newnodetemp.label = resolution
                     if newnodetemp in nodedict:
                         newnode = nodedict[newnodetemp]
@@ -1059,10 +1104,10 @@ def leaf_path_uncertainty_dag(self, leaf_label):
         parent_dictionary = {
             node.label: set()
             for node in self.dagroot.children()
-            if leaf_label in node.under_clade()
+            if leaf_label in node.clade_union()
         }
 
-        for node in self.preorder(skip_root=True):
+        for node in self.preorder(skip_ua_node=True):
             for clade, eset in node.clades.items():
                 if leaf_label in clade:
                     for cnode in eset.targets:
@@ -1110,7 +1155,7 @@ def leaf_path_uncertainty_graphviz_collapse(
                         parent.label == parent_label
                         and child.label == child_label
                         and (
-                            leaf_label in child.under_clade()
+                            leaf_label in child.clade_union()
                             or (child.label == leaf_label and child.is_leaf())
                         )
                     ):
@@ -1165,11 +1210,11 @@ def leaf_path_uncertainty_dag_no_collapse(self, leaf_label):
         parent_dictionary = {
             node: set()
             for node in self.dagroot.children()
-            if leaf_label in node.under_clade()
+            if leaf_label in node.clade_union()
             or (node.is_leaf() and node.label == leaf_label)
         }
 
-        for node in self.preorder(skip_root=True):
+        for node in self.preorder(skip_ua_node=True):
             for clade, eset in node.clades.items():
                 if leaf_label in clade:
                     for cnode in eset.targets:
@@ -1225,7 +1270,7 @@ def leaf_path_uncertainty_graphviz_no_collapse(
     def summary(self):
         """Print nicely formatted summary about the history DAG."""
         print(f"Nodes:\t{sum(1 for _ in self.postorder())}")
-        print(f"Trees:\t{self.count_trees()}")
+        print(f"Trees:\t{self.count_histories()}")
         utils.hist(self.weight_counts_with_ambiguities())
 
     def label_uncertainty_summary(self):
@@ -1233,8 +1278,8 @@ def label_uncertainty_summary(self):
         clades but different labels."""
         duplicates = list(
             Counter(
-                node.partitions()
-                for node in self.preorder(skip_root=True)
+                node.child_clades()
+                for node in self.preorder(skip_ua_node=True)
                 if not node.is_leaf()
             ).values()
         )
@@ -1250,7 +1295,7 @@ def label_uncertainty_summary(self):
 
     # ######## Abstract dp method and derivatives: ########
 
-    def postorder_cladetree_accum(
+    def postorder_history_accum(
         self,
         leaf_func: Callable[["HistoryDagNode"], Weight],
         edge_func: Callable[["HistoryDagNode", "HistoryDagNode"], Weight],
@@ -1307,6 +1352,10 @@ def default_accum_above_edge(subtree_weight, edge_weight):
                 )
         return self.dagroot._dp_data
 
+    def postorder_cladetree_accum(self, *args, **kwargs) -> Weight:
+        """Deprecated name for :meth:`postorder_history_accum`"""
+        return self.postorder_history_accum(*args, **kwargs)
+
     def optimal_weight_annotate(
         self,
         start_func: Callable[["HistoryDagNode"], Weight] = lambda n: 0,
@@ -1319,7 +1368,7 @@ def optimal_weight_annotate(
         r"""A template method for finding the optimal tree weight in the DAG.
         Dynamically annotates each node in the DAG with the optimal weight of a clade
         sub-tree beneath it, so that the DAG root node is annotated with the optimal
-        weight of a clade tree in the DAG.
+        weight of a history in the DAG.
 
         Args:
             start_func: A function which assigns starting weights to leaves.
@@ -1333,7 +1382,7 @@ def optimal_weight_annotate(
         Returns:
             The optimal weight of a tree under the DAG UA node.
         """
-        return self.postorder_cladetree_accum(
+        return self.postorder_history_accum(
             start_func,
             edge_weight_func,
             optimal_func,
@@ -1361,7 +1410,7 @@ def weight_count(
         Returns:
             A Counter keyed by weights.
         """
-        return self.postorder_cladetree_accum(
+        return self.postorder_history_accum(
             lambda n: Counter([start_func(n)]),
             lambda n1, n2: Counter([edge_weight_func(n1, n2)]),
             counter_sum,
@@ -1391,7 +1440,7 @@ def count_topologies(self, collapse_leaves: bool = False) -> int:
         achieved by counting the number of unique newick strings with only
         leaves labeled.
 
-        :meth:`count_trees` gives the total number of unique trees in the DAG, taking
+        :meth:`count_histories` gives the total number of unique trees in the DAG, taking
         into account internal node labels.
 
         For large DAGs, this method is prohibitively slow. Use :meth:``count_topologies_fast`` instead.
@@ -1420,9 +1469,13 @@ def count_topologies_fast(self) -> int:
         This is only guaranteed to match the output of ``count_topologies``
         if the DAG has all allowed edges added.
         """
-        return self.unlabel().count_trees()
+        return self.unlabel().count_histories()
 
-    def count_trees(
+    def count_trees(self):
+        """Deprecated name for :meth:`count_histories`"""
+        return self.count_histories()
+
+    def count_histories(
         self,
         expand_func: Optional[Callable[[Label], List[Label]]] = None,
         expand_count_func: Callable[[Label], int] = lambda ls: 1,
@@ -1432,7 +1485,7 @@ def count_trees(
         Args:
             expand_func: A function which takes a label and returns a list of labels, for
                 example disambiguations of an ambiguous sequence. If provided, this method
-                will count at least the number of clade trees that would be in the DAG,
+                will count at least the number of histories that would be in the DAG,
                 if :meth:`explode_nodes` were called with the same `expand_func`.
             expand_count_func: A function which takes a label and returns an integer value
                 corresponding to the number of 'disambiguations' of that label. If provided,
@@ -1448,7 +1501,7 @@ def count_trees(
             def expand_count_func(label):
                 return len(list(expand_func(label)))
 
-        return self.postorder_cladetree_accum(
+        return self.postorder_history_accum(
             lambda n: 1,
             lambda parent, child: expand_count_func(child.label),
             sum,
@@ -1470,13 +1523,13 @@ def count_nodes(self, collapse=False) -> Dict[HistoryDagNode, int]:
         node2count = {}
         node2stats = {}
 
-        self.count_trees()
+        self.count_histories()
         reverse_postorder = reversed(list(self.postorder()))
         for node in reverse_postorder:
             below = node._dp_data
-            curr_clade = node.under_clade()
+            curr_clade = node.clade_union()
 
-            if node.is_root():
+            if node.is_ua_node():
                 above = 1
             else:
                 above = 0
@@ -1485,7 +1538,7 @@ def count_nodes(self, collapse=False) -> Dict[HistoryDagNode, int]:
                     below_parent = 1
                     for clade in parent.clades:
                         # Skip clade covered by node of interest
-                        if clade == curr_clade or parent.is_root():
+                        if clade == curr_clade or parent.is_ua_node():
                             continue
                         below_clade = 0
                         for sib in parent.children(clade=clade):
@@ -1500,7 +1553,7 @@ def count_nodes(self, collapse=False) -> Dict[HistoryDagNode, int]:
         collapsed_n2c = {}
         if collapse:
             for node in node2count.keys():
-                clade = node.under_clade()
+                clade = node.clade_union()
                 if clade not in collapsed_n2c:
                     collapsed_n2c[clade] = 0
 
@@ -1522,13 +1575,13 @@ def count_edges(
         edge2count = {}
         node2stats = {}
 
-        self.count_trees()
+        self.count_histories()
         reverse_postorder = reversed(list(self.postorder()))
         for node in reverse_postorder:
             below = node._dp_data
-            curr_clade = node.under_clade()
+            curr_clade = node.clade_union()
 
-            if node.is_root():
+            if node.is_ua_node():
                 above = 1
             else:
                 above = 0
@@ -1537,7 +1590,7 @@ def count_edges(
                     below_parent = 1
                     for clade in parent.clades:
                         # Skip clade covered by node of interest
-                        if clade == curr_clade or parent.is_root():
+                        if clade == curr_clade or parent.is_ua_node():
                             continue
                         below_clade = 0
                         for sib in parent.children(clade=clade):
@@ -1552,8 +1605,8 @@ def count_edges(
         e2c = {}
         if collapsed:
             for (parent, child), count in edge2count.items():
-                parent_cu = parent.under_clade()
-                child_cu = child.under_clade()
+                parent_cu = parent.clade_union()
+                child_cu = child.clade_union()
                 if (parent_cu, child_cu) not in e2c:
                     e2c[(parent_cu, child_cu)] = 0
                 e2c[(parent_cu, child_cu)] += count
@@ -1565,18 +1618,18 @@ def most_supported_trees(self):
         """Trims the DAG to only express the trees that have the highest
         support."""
         node2count = self.count_nodes()
-        total_trees = self.count_trees()
+        total_trees = self.count_histories()
         clade2support = {}
         for node, count in node2count.items():
-            if node.under_clade() not in clade2support:
-                clade2support[node.under_clade()] = 0
-            clade2support[node.under_clade()] += count / total_trees
+            if node.clade_union() not in clade2support:
+                clade2support[node.clade_union()] = 0
+            clade2support[node.clade_union()] += count / total_trees
 
         from math import log
 
         self.trim_optimal_weight(
             start_func=lambda n: 0,
-            edge_weight_func=lambda n1, n2: log(clade2support[n2.under_clade()]),
+            edge_weight_func=lambda n1, n2: log(clade2support[n2.clade_union()]),
             accum_func=lambda weights: sum([w for w in weights]),
             optimal_func=max,
         )
@@ -1595,7 +1648,7 @@ def count_paths_to_leaf(
             leaf_label: The label of the leaf node of interest
             expand_func: A function which takes a label and returns a list of labels, for
                 example disambiguations of an ambiguous sequence. If provided, this method
-                will count at least the number of clade trees that would be in the DAG,
+                will count at least the number of histories that would be in the DAG,
                 if :meth:`explode_nodes` were called with the same `expand_func`.
             expand_count_func: A function which takes a label and returns an integer value
                 corresponding to the number of 'disambiguations' of that label. If provided,
@@ -1611,7 +1664,7 @@ def count_paths_to_leaf(
             def expand_count_func(label):
                 return len(list(expand_func(label)))
 
-        return self.postorder_cladetree_accum(
+        return self.postorder_history_accum(
             lambda n: 1 if n.label == leaf_label else 0,
             lambda parent, child: 0,
             sum,
@@ -1629,7 +1682,7 @@ def weight_counts_with_ambiguities(
     ):
         r"""Template method for counting tree weights in the DAG, with exploded labels.
         Like :meth:`weight_counts`, but creates dictionaries of Counter objects at each
-        node, keyed by possible sequences at that node. Analogous to :meth:`count_trees`
+        node, keyed by possible sequences at that node. Analogous to :meth:`count_histories`
         with `expand_func` provided.
 
         Weights must be hashable.
@@ -1645,18 +1698,18 @@ def weight_counts_with_ambiguities(
 
         Returns:
             A Counter keyed by weights.
-            The total number of trees will be greater than count_trees(), as these are
+            The total number of trees will be greater than count_histories(), as these are
             possible disambiguations of trees. These disambiguations may not be unique,
             but if two are the same, they come from different subtrees of the DAG.
         """
 
-        def wrapped_expand_func(label, is_root):
-            if is_root:
+        def wrapped_expand_func(label, is_ua_node):
+            if is_ua_node:
                 return [label]
             else:
                 return expand_func(label)
 
-        # The old direct implementation not using postorder_cladetree_accum was
+        # The old direct implementation not using postorder_history_accum was
         # more straightforward, and may be significantly faster.
         def leaf_func(node):
             return {
@@ -1678,7 +1731,7 @@ def edge_weight_func(parent, child):
                     ]
                 )
                 for childlabel, target_wc in child._dp_data.items()
-                for label in wrapped_expand_func(parent.label, parent.is_root())
+                for label in wrapped_expand_func(parent.label, parent.is_ua_node())
             }
 
         def accum_within_clade(dictlist):
@@ -1693,7 +1746,7 @@ def accum_between_clade(dictlist):
             }
 
         return list(
-            self.postorder_cladetree_accum(
+            self.postorder_history_accum(
                 leaf_func,
                 edge_weight_func,
                 accum_within_clade,
@@ -1827,7 +1880,7 @@ def convert_to_collapsed(self):
         r"""Rebuilds the DAG so that no edge connects two nodes with the same label,
         unless one is a leaf node.
 
-        The resulting DAG should express at least the collapsed clade trees present
+        The resulting DAG should express at least the collapsed histories present
         in the original.
         """
 
@@ -1840,7 +1893,7 @@ def convert_to_collapsed(self):
 
         while edgequeue:
             parent, child = edgequeue.pop()
-            clade = child.under_clade()
+            clade = child.clade_union()
             if (
                 parent.label == child.label
                 and parent in nodedict
@@ -1881,7 +1934,7 @@ def convert_to_collapsed(self):
                     # Remove old parent as child of all of its parents
                     # no need for recursion here, all of its parents had
                     # edges added to new parent from the same clade.
-                    upclade = parent.under_clade()
+                    upclade = parent.clade_union()
                     for grandparent in sorted(parent.parents):
                         grandparent.remove_edge_by_clade_and_id(parent, upclade)
                     for child2 in parent.children():
@@ -1920,15 +1973,23 @@ def traverse(node: HistoryDagNode):
 
         yield from traverse(self.dagroot)
 
-    def preorder(self, skip_root=False) -> Generator[HistoryDagNode, None, None]:
+    def preorder(
+        self, skip_ua_node=False, skip_root=None
+    ) -> Generator[HistoryDagNode, None, None]:
         """Recursive postorder traversal of the history DAG.
 
         Careful! This is not guaranteed to visit a parent node before any of its children.
         for that, need reverse postorder traversal.
 
+        If skip_ua_node is passed, the universal ancestor node will be skipped.
+        skip_root is provided as a backwards-compatible synonym of skip_ua_node.
+
         Returns:
             Generator on nodes
         """
+        if skip_root is not None:
+            skip_ua_node = skip_root
+
         visited = set()
 
         def traverse(node: HistoryDagNode):
@@ -1940,7 +2001,7 @@ def traverse(node: HistoryDagNode):
                         yield from traverse(child)
 
         gen = traverse(self.dagroot)
-        if skip_root:
+        if skip_ua_node:
             next(gen)
         yield from gen
 
@@ -2060,7 +2121,7 @@ def add_to_edgeset(self, target, weight=0, prob=None, prob_norm=True) -> bool:
         Returns:
             Whether an edge was added
         """
-        if target.is_root():
+        if target.is_ua_node():
             raise ValueError(
                 "Edges that target UA nodes are not allowed. "
                 f"Target node has label {target.label} and therefore "
@@ -2103,7 +2164,7 @@ def from_tree(
     """Build a full tree from an ete3 TreeNode.
 
     Args:
-        tree: ete3 tree to be converted to HistoryDag clade tree
+        tree: ete3 tree to be converted to HistoryDag history
         label_features: node attribute names to be used to distinguish nodes. Field names
             provided in `label_functions` will take precedence.
         label_functions: dictionary keyed by additional label field names, containing
@@ -2208,7 +2269,7 @@ def history_dag_from_newicks(
 
     See :meth:`from_newick` for argument details.
     """
-    return history_dag_from_clade_trees(
+    return history_dag_from_histories(
         [
             from_newick(
                 tree,
@@ -2232,7 +2293,7 @@ def history_dag_from_etes(
 
     See :meth:`from_tree` for argument details.
     """
-    return history_dag_from_clade_trees(
+    return history_dag_from_histories(
         [
             from_tree(
                 tree,
@@ -2245,25 +2306,29 @@ def history_dag_from_etes(
     )
 
 
-def history_dag_from_clade_trees(treelist: Sequence[HistoryDag]) -> HistoryDag:
-    """Build a history DAG from a list of history DAGs which are clade
-    trees."""
+def history_dag_from_histories(treelist: Sequence[HistoryDag]) -> HistoryDag:
+    """Build a history DAG from a list of history DAGs which are histories."""
     dag = next(iter(treelist))
     dag.merge(treelist)
     return dag
 
 
+def history_dag_from_clade_trees(*args, **kwargs) -> HistoryDag:
+    """Deprecated name for :meth:`history_dag_from_histories`"""
+    return history_dag_from_histories(*args, **kwargs)
+
+
 def history_dag_from_nodes(nodes: Sequence[HistoryDagNode]) -> HistoryDag:
     """Take an iterable containing HistoryDagNodes, and build a HistoryDag from
     those nodes."""
     # use dictionary to preserve order
-    nodes = {node.node_self(): node for node in nodes}
+    nodes = {node.empty_copy(): node for node in nodes}
     # check for UA node in passed set, and recover if present:
     ua_node = UANode(EdgeSet())
     if ua_node in nodes:
-        ua_node = nodes[ua_node].node_self()
+        ua_node = nodes[ua_node].empty_copy()
     nodes.pop(ua_node)
-    clade_dict = _under_clade_dict(nodes.keys())
+    clade_dict = _clade_union_dict(nodes.keys())
     edge_dict = {
         node: [child for clade in node.clades for child in clade_dict[clade]]
         for node in nodes
diff --git a/historydag/parsimony.py b/historydag/parsimony.py
index c58e240..a4c079e 100644
--- a/historydag/parsimony.py
+++ b/historydag/parsimony.py
@@ -6,7 +6,7 @@
 import Bio.Data.IUPACData
 from itertools import product
 from historydag.dag import (
-    history_dag_from_clade_trees,
+    history_dag_from_histories,
     history_dag_from_etes,
     HistoryDag,
 )
@@ -72,7 +72,7 @@ def _get_adj_array(seq_len, transition_weights=None):
 
 
 def edge_weight_func_from_weight_matrix(n1, n2, weight_mat=None, bases=None):
-    if n1.is_root() or n2.is_root():
+    if n1.is_ua_node() or n2.is_ua_node():
         return 0
     if len(n1.label.sequence) != len(n2.label.sequence):
         raise ValueError("Sequences must have the same length!")
@@ -224,14 +224,14 @@ def accum_between_clade_with_filtering(clade_data):
         else:
             clade_func = accum_between_clade
 
-        tree.postorder_cladetree_accum(
+        tree.postorder_history_accum(
             leaf_func=leaf_func,
             edge_func=lambda x, y: y,
             accum_within_clade=lambda x: x,
             accum_between_clade=clade_func,
             accum_above_edge=lambda x, y: y,
         )
-        return next(tree.preorder(skip_root=True))._dp_data["subtree_cost"]
+        return next(tree.preorder(skip_ua_node=True))._dp_data["subtree_cost"]
     else:
         return 0
 
@@ -302,13 +302,13 @@ def compute_sequence_data(cost_vector):
     dag_nodes = {}
     # downward pass of Sankoff: find and assign sequence labels to each internal node
     for node in reversed(list(dag.postorder())):
-        if not (node.is_leaf() or node.is_root()):
+        if not (node.is_leaf() or node.is_ua_node()):
             node_data = {k: v for k, v in node._dp_data.items()}
             node_copies = {}
             node_children = set(node.children())
             node_parents = set(node.parents)
             for p in node_parents:
-                if p.is_root():
+                if p.is_ua_node():
                     new_seq_data = [
                         y
                         for cv in node._dp_data["cost_vectors"]
@@ -331,7 +331,7 @@ def compute_sequence_data(cost_vector):
 
                 for nsd in new_seq_data:
                     if (nsd[-1] <= min_val) and (nsd[0] not in node_copies):
-                        new_node = node.node_self()
+                        new_node = node.empty_copy()
                         new_node.label = node.label._replace(sequence=nsd[0])
                         new_node._dp_data = deepcopy(node_data)
                         new_node._dp_data["transition_cost"] = nsd[1]
@@ -340,7 +340,7 @@ def compute_sequence_data(cost_vector):
             for c in node_children:
                 c.parents.remove(node)
             for p in node_parents:
-                p.remove_edge_by_clade_and_id(node, node.under_clade())
+                p.remove_edge_by_clade_and_id(node, node.clade_union())
             # add all new copies of current node(with alt sequence labels) into the dag
             for new_sequence, new_node in node_copies.items():
                 if new_node in dag_nodes:
@@ -509,9 +509,9 @@ def build_tree(
     seq_len = len(next(iter(fasta_map.values())))
     ambig_seq = "?" * seq_len
     for node in tree.traverse():
-        if node.is_root() and reference_sequence is not None:
+        if node.is_ua_node() and reference_sequence is not None:
             node.add_feature("sequence", reference_sequence)
-        elif node.is_root() and reference_id is not None:
+        elif node.is_ua_node() and reference_id is not None:
             node.add_feature("sequence", fasta_map[reference_id])
         elif (not node.is_leaf()) and ignore_internal_sequences:
             node.add_feature("sequence", ambig_seq)
@@ -623,7 +623,7 @@ def build_dag_from_trees(trees):
 def summarize_dag(dag):
     """print summary information about the provided history DAG."""
     print("DAG contains")
-    print("trees: ", dag.count_trees())
+    print("trees: ", dag.count_histories())
     print("nodes: ", len(list(dag.preorder())))
     print("edges: ", sum(len(list(node.children())) for node in dag.preorder()))
     print("parsimony scores: ", dag.weight_count())
@@ -646,12 +646,12 @@ def disambiguate_history(history):
 
 def treewise_sankoff_in_dag(dag, cover_edges=False):
     """Perform tree-wise sankoff to compute labels for all nodes in the DAG."""
-    newdag = history_dag_from_clade_trees(
+    newdag = history_dag_from_histories(
         disambiguate_history(history)
         for history in dag.iter_covering_histories(cover_edges=cover_edges)
     )
     newdag.explode_nodes()
-    newdag.add_all_allowed_edges()
+    newdag.make_complete()
     newdag.trim_optimal_weight()
     newdag.convert_to_collapsed()
     return newdag
diff --git a/historydag/utils.py b/historydag/utils.py
index d84d0f1..284008e 100644
--- a/historydag/utils.py
+++ b/historydag/utils.py
@@ -62,7 +62,7 @@ def access_nodefield_default(fieldname: str, default: Any) -> Any:
         default: A value that should be returned if one of the arguments is the DAG UA node.
 
     For example, instead of
-    `lambda n1, n2: default if n1.is_root() or n2.is_root() else func(n1.label.fieldname, n2.label.fieldname)`,
+    `lambda n1, n2: default if n1.is_ua_node() or n2.is_ua_node() else func(n1.label.fieldname, n2.label.fieldname)`,
     this wrapper allows one to write `access_nodefield_default(fieldname, default)(func)`.
     """
 
@@ -111,7 +111,7 @@ def decorator(func):
         @wraps(func)
         def wrapper(*args: "HistoryDagNode", **kwargs: Any):
             for node in args:
-                if node.is_root():
+                if node.is_ua_node():
                     return default
             else:
                 return func(*args, **kwargs)
@@ -473,15 +473,15 @@ def _newickedgeweight(n1, n2):
     )
 
 
-def _cladetree_method(method):
+def _history_method(method):
     """HistoryDagNode method decorator to ensure that the method is only run on
-    history DAGs which are clade trees."""
+    history DAGs which are histories."""
 
     @wraps(method)
     def wrapper(self, *args, **kwargs):
-        if not self.is_clade_tree():
+        if not self.is_history():
             raise ValueError(
-                "to_newick requires the history DAG to be a clade tree. "
+                "to_newick requires the history DAG to be a history. "
                 "To extract newicks from a general DAG, see to_newicks"
             )
         else:
diff --git a/scripts/agg_mut.py b/scripts/agg_mut.py
index 14cb9fd..157a5b7 100644
--- a/scripts/agg_mut.py
+++ b/scripts/agg_mut.py
@@ -42,10 +42,10 @@ def merge(first, others, accumulation_data=None, resolution=10):
 
     def compute_accum_data(dag):
         tdag = dag.copy()
-        tdag.add_all_allowed_edges()
+        tdag.make_complete()
         pscore = tdag.trim_optimal_weight(edge_weight_func=dist)
         tdag.convert_to_collapsed()
-        ntrees = tdag.count_trees()
+        ntrees = tdag.count_histories()
         return ntrees, pscore
 
     if accumulation_data is not None:
@@ -57,7 +57,7 @@ def compute_accum_data(dag):
             if n in nodedict:
                 pnode = nodedict[n]
             else:
-                pnode = n.node_self()
+                pnode = n.empty_copy()
                 nodedict[n] = pnode
 
             for _, edgeset in n.clades.items():
@@ -112,7 +112,7 @@ def process_from_mat(file, refseqid, known_node_cg=frozendict({})):
         known_node = tree
 
     known_node.add_feature("mutseq", known_node_cg)
-    while not known_node.is_root():
+    while not known_node.is_ua_node():
         known_node.up.add_feature("mutseq", apply_muts(known_node.mutseq, known_node.mutations, reverse=True))
         known_node = known_node.up
     
@@ -123,7 +123,7 @@ def process_from_mat(file, refseqid, known_node_cg=frozendict({})):
     #         tree.children[0].delete(prevent_nondicotomic=False)
     # remove unifurcations
     while True:
-        to_delete = [node for node in tree.traverse() if len(node.children) == 1 and not node.is_root()]
+        to_delete = [node for node in tree.traverse() if len(node.children) == 1 and not node.is_ua_node()]
         if len(to_delete) == 0:
             break
         for node in to_delete:
@@ -265,7 +265,7 @@ def dag_to_mad_pb(dag, leaf_data_func=None, from_mutseqs=True):
     if from_mutseqs:
         refseqid, refseq = dag.refseq
         def mut_func(pnode, cnode):
-            if pnode.is_root():
+            if pnode.is_ua_node():
                 parent_seq = frozendict()
             else:
                 parent_seq = pnode.label.mutseq
@@ -275,10 +275,10 @@ def key_func(cladeitem):
             clade, _ = cladeitem
             return sorted(sorted(idx for idx in label.mutseq) for label in clade)
     else:
-        refseq = next(dag.preorder(skip_root=True)).label.sequence
+        refseq = next(dag.preorder(skip_ua_node=True)).label.sequence
         refseqid = 'unknown_seq_id'
         def mut_func(pnode, cnode):
-            if pnode.is_root():
+            if pnode.is_ua_node():
                 parent_seq = refseq
             else:
                 parent_seq = pnode.label.sequence
@@ -419,15 +419,15 @@ def summarize(dagpath, treedir, outfile, csv_data, print_header):
     """output summary information about the provided input file(s)"""
     dag = load_dag(dagpath)
     data = []
-    data.append(("before_collapse_n_trees", dag.count_trees()))
+    data.append(("before_collapse_n_trees", dag.count_histories()))
     data.append(("before_collapse_n_nodes", len(list(dag.preorder()))))
     wc = dag.weight_count(edge_weight_func=dist)
     data.append(("before_collapse_max_pars", max(wc.keys())))
     data.append(("before_collapse_min_pars", min(wc.keys())))
-    dag.add_all_allowed_edges()
+    dag.make_complete()
     dag.trim_optimal_weight(edge_weight_func=dist)
     dag.convert_to_collapsed()
-    data.append(("n_trees", dag.count_trees()))
+    data.append(("n_trees", dag.count_histories()))
     wc = dag.weight_count(edge_weight_func=dist)
     data.append(("parsimony_score", min(wc.keys())))
     data.append(("avg_node_parents", dag.internal_avg_parents()))
@@ -601,7 +601,7 @@ def reroot(new_root):
     """
     node_path = [new_root]
     curr = new_root
-    while not curr.is_root():
+    while not curr.is_ua_node():
         node_path.append(curr.up)
         curr = curr.up
 
@@ -887,7 +887,7 @@ def get_child_clades(node):
         return [frozenset(cg_indices[label] for label in clade) for clade in node.clades]
 
     def get_compact_genome(node):
-        if node.is_root():
+        if node.is_ua_node():
             return []
         else:
             ret = [[idx, list(bases)] for idx, bases in node.label.mutseq.items()]
@@ -978,7 +978,7 @@ def make_testcase(pickled_forest, outdir, num_trees, random_seed):
     except AttributeError:
         dag = forest
     trees = [dag.sample() for _ in range(int(num_trees))]
-    refseqs = [next(tree.preorder(skip_root=True)).label.sequence for tree in trees]
+    refseqs = [next(tree.preorder(skip_ua_node=True)).label.sequence for tree in trees]
     assert len(set(refseqs)) == 1
     # These dags have full sequence strings instead of compact genomes, which
     # is why we pass from_mutseqs to write_dag (which passes it on to
@@ -989,7 +989,7 @@ def make_testcase(pickled_forest, outdir, num_trees, random_seed):
     for tree in trees[1:]:
         newdag.merge(tree)
     write_dag(newdag, outdir / "full_dag.pb", from_mutseqs=False)
-    print(f"Test case dag contains {newdag.count_trees()} trees")
+    print(f"Test case dag contains {newdag.count_histories()} trees")
 
 @cli.command("change-ref")
 @click.argument("in_pb")
@@ -1130,7 +1130,7 @@ def distance_between_nodes(n1, n2):
     """ Returns the hamming distance between two hdag nodes that represent their sequences with
     collapsed genomes
     """
-    if n1.is_root() or n2.is_root():
+    if n1.is_ua_node() or n2.is_ua_node():
         return 0
     else:
         return distance(n1.label.mutseq, n2.label.mutseq)
@@ -1275,7 +1275,7 @@ def annotate_support(subset_mat_file, reference_file, clade_dir, unique_seqs_fil
     verbose = False # NOTE: Very slow to count all the trees!
 
     print("Merging tree dag into hdag...")
-    print(f"\t{dag.count_trees()} trees before merge")
+    print(f"\t{dag.count_histories()} trees before merge")
     if verbose:
         hist = dag.weight_count(edge_weight_func=distance_between_nodes)
         for k, v in hist.items():
@@ -1290,16 +1290,16 @@ def annotate_support(subset_mat_file, reference_file, clade_dir, unique_seqs_fil
 
     dag.merge([toidag])
     if verbose:
-        print(f"\t{dag.count_trees()} trees after merge")
+        print(f"\t{dag.count_histories()} trees after merge")
         hist = dag.weight_count(edge_weight_func=distance_between_nodes)
         for k, v in hist.items():
             print(k, "\t", v)
         print()
         with open(clade_dir + "/parsimony_hists/after_merge.pkl", "wb") as f:
             pickle.dump(hist, f)
-    dag.add_all_allowed_edges()
+    dag.make_complete()
     if False:   # NOTE: For many clades this is infeasible to compute in a reasonable amount of time
-        print(f"\t{dag.count_trees()} after adding edges")
+        print(f"\t{dag.count_histories()} after adding edges")
         hist = dag.weight_count(edge_weight_func=distance_between_nodes)
         for k, v in hist.items():
             print(k, "\t", v)
@@ -1315,7 +1315,7 @@ def annotate_support(subset_mat_file, reference_file, clade_dir, unique_seqs_fil
         with open(clade_dir + "/trimmed_dag.pkl", "wb") as f:
             pickle.dump(dag, f)
         hist = dag.weight_count(edge_weight_func=distance_between_nodes)
-        print(f"\t{dag.count_trees()} trees after trim")
+        print(f"\t{dag.count_histories()} trees after trim")
         if verbose:
             with open(clade_dir + "/parsimony_hists/after_trim.pkl", "wb") as f:
                 pickle.dump(hist, f)
@@ -1337,7 +1337,7 @@ def annotate_support(subset_mat_file, reference_file, clade_dir, unique_seqs_fil
     
     for node in tree.traverse():
         if not node.is_leaf():
-            print(node.support, "\troot:", node.is_root())
+            print(node.support, "\troot:", node.is_ua_node())
 
     print(f"\t--- Annotation took {time.time() - begin} seconds ---")
     num_uncertain = 0
@@ -1364,7 +1364,7 @@ def annotate_ete(dag, tree):
     node2count = dag.count_nodes()
     print(f"\t--- Counting took {time.time() - start_time} seconds ---")
 
-    total_trees = dag.count_trees()
+    total_trees = dag.count_histories()
     
     print(f"hDAG contains {total_trees} trees")
 
@@ -1376,7 +1376,7 @@ def annotate_ete(dag, tree):
         if node.is_leaf():
             clade_union = frozenset([node.label.mutseq])
         else:
-            clade_union = frozenset([label.mutseq for label in node.under_clade()])
+            clade_union = frozenset([label.mutseq for label in node.clade_union()])
 
         if clade_union not in clade2support:
             clade2support[clade_union] = 0
@@ -1835,16 +1835,16 @@ def most_supported_trees(dag):
     """ Trims the DAG to only express the trees that have the highest support.
     """
     node2count = dag.count_nodes()        
-    total_trees = dag.count_trees()
+    total_trees = dag.count_histories()
     clade2support = {}
     for node, count in node2count.items():
-        if node.under_clade() not in clade2support:
-            clade2support[node.under_clade()] = 0
-        clade2support[node.under_clade()] += count / total_trees
+        if node.clade_union() not in clade2support:
+            clade2support[node.clade_union()] = 0
+        clade2support[node.clade_union()] += count / total_trees
 
     dag.trim_optimal_weight(
         start_func= lambda n: 0,
-        edge_weight_func= lambda n1, n2: log(clade2support[n2.under_clade()]),
+        edge_weight_func= lambda n1, n2: log(clade2support[n2.clade_union()]),
         accum_func= lambda weights: sum([w for w in weights]),
         optimal_func=max,
         #TODO: Add equality_func that checks first 5 decimals
@@ -1856,16 +1856,16 @@ def most_supported_trees(dag):
 def support_count(dag, clade2support=None):
     if clade2support is None:
         node2count = dag.count_nodes()        
-        total_trees = dag.count_trees()
+        total_trees = dag.count_histories()
         clade2support = {}
         for node, count in node2count.items():
-            if node.under_clade() not in clade2support:
-                clade2support[node.under_clade()] = 0
-            clade2support[node.under_clade()] += count / total_trees
+            if node.clade_union() not in clade2support:
+                clade2support[node.clade_union()] = 0
+            clade2support[node.clade_union()] += count / total_trees
     
     support_hist = Counter()
     for node in dag.postorder():
-        support_hist[clade2support[node.under_clade()]] += 1
+        support_hist[clade2support[node.clade_union()]] += 1
     return support_hist
 
 
@@ -1898,18 +1898,18 @@ def explore_most_supported_trees():
         toi_sups.append(toi_support)
 
         node2count = dag.count_nodes()        
-        total_trees = dag.count_trees()
+        total_trees = dag.count_histories()
         clade2support = {}
         for node, count in node2count.items():
-            if node.under_clade() not in clade2support:
-                clade2support[node.under_clade()] = 0
-            clade2support[node.under_clade()] += count / total_trees
+            if node.clade_union() not in clade2support:
+                clade2support[node.clade_union()] = 0
+            clade2support[node.clade_union()] += count / total_trees
         
-        num_trees_before = dag.count_trees()
+        num_trees_before = dag.count_histories()
         support_hist = support_count(dag, clade2support)
         best_sup = most_supported_trees(dag)
         best_sups.append(best_sup)
-        num_trees_after = dag.count_trees()
+        num_trees_after = dag.count_histories()
 
         print(f"\t{num_trees_before} -> {num_trees_after}\tsup: {best_sup}\ttoi_sup: {toi_support}")
         # print("\tsupport hist:", support_hist)
diff --git a/scripts/parsimony.py b/scripts/parsimony.py
index e528ccf..5cbcdaa 100644
--- a/scripts/parsimony.py
+++ b/scripts/parsimony.py
@@ -538,7 +538,7 @@ def _cli_parsimony_score_from_files(
 def summarize_dag(dag):
     """print summary information about the provided history DAG."""
     print("DAG contains")
-    print("trees: ", dag.count_trees())
+    print("trees: ", dag.count_histories())
     print("nodes: ", len(list(dag.preorder())))
     print("edges: ", sum(len(list(node.children())) for node in dag.preorder()))
     print("parsimony scores: ", dag.weight_count())
diff --git a/tests/test_collapse.py b/tests/test_collapse.py
index 0eab1d3..ff4a838 100644
--- a/tests/test_collapse.py
+++ b/tests/test_collapse.py
@@ -33,7 +33,7 @@ def collapse_adjacent_sequences(tree: ete3.TreeNode) -> ete3.TreeNode:
 etetree = list(
     hdag.history_dag_from_etes(
         [ete3.TreeNode(newick=newickstring3, format=1)], ["sequence"]
-    ).get_trees()
+    ).get_histories()
 )[0].to_ete(features=["sequence"])
 etetree2 = utils.collapse_adjacent_sequences(etetree.copy())
 
@@ -56,17 +56,17 @@ def test_fulltree():
     dag = hdag.history_dag_from_etes([etetree], ["sequence"])
     dag.convert_to_collapsed()
     dag._check_valid()
-    assert set(deterministic_newick(tree.to_ete()) for tree in dag.get_trees()) == set(
-        {deterministic_newick(etetree2)}
-    )
+    assert set(
+        deterministic_newick(tree.to_ete()) for tree in dag.get_histories()
+    ) == set({deterministic_newick(etetree2)})
 
 
 def test_twotrees():
     dag = hdag.history_dag_from_etes([etetree, etetree2], ["sequence"])
     dag.convert_to_collapsed()
     dag._check_valid()
-    assert dag.count_trees() == 1
-    assert {deterministic_newick(tree.to_ete()) for tree in dag.get_trees()} == {
+    assert dag.count_histories() == 1
+    assert {deterministic_newick(tree.to_ete()) for tree in dag.get_histories()} == {
         deterministic_newick(etetree2)
     }
 
@@ -78,18 +78,18 @@ def test_collapse():
     allcollapsedtrees = [utils.collapse_adjacent_sequences(tree) for tree in trees]
     collapsed_dag = hdag.history_dag_from_etes(allcollapsedtrees, ["sequence"])
     collapsed_dag._check_valid()
-    maybecollapsedtrees = [tree.to_ete() for tree in uncollapsed_dag.get_trees()]
+    maybecollapsedtrees = [tree.to_ete() for tree in uncollapsed_dag.get_histories()]
     assert all(utils.is_collapsed(tree) for tree in maybecollapsedtrees)
-    n_before = uncollapsed_dag.count_trees()
+    n_before = uncollapsed_dag.count_histories()
     uncollapsed_dag.merge(collapsed_dag)
     uncollapsed_dag._check_valid()
-    assert n_before == uncollapsed_dag.count_trees()
+    assert n_before == uncollapsed_dag.count_histories()
 
 
 def test_add_allowed_edges():
     # See that adding only edges that preserve parent labels preserves parsimony
     dag = hdag.history_dag_from_etes(trees, ["sequence"])
-    dag.add_all_allowed_edges(preserve_parent_labels=True)
+    dag.make_complete(preserve_parent_labels=True)
     dag._check_valid()
     c = dag.weight_count()
     assert min(c) == max(c)
@@ -100,7 +100,7 @@ def test_add_allowed_edges():
     collapsed_dag._check_valid()
     collapsed_dag.convert_to_collapsed()
     collapsed_dag._check_valid()
-    collapsed_dag.add_all_allowed_edges(adjacent_labels=False)
+    collapsed_dag.make_complete(adjacent_labels=False)
     collapsed_dag._check_valid()
     assert all(
         parent.label != target.label
diff --git a/tests/test_dag_sankoff.py b/tests/test_dag_sankoff.py
index 059c911..47ac301 100644
--- a/tests/test_dag_sankoff.py
+++ b/tests/test_dag_sankoff.py
@@ -54,9 +54,9 @@ def weight_func(x, y):
         s_weight == s_ete_weight
     ), "Downward sankoff on ete_Tree vs on the dag version of the tree produced different results"
 
-    s_labels = set(n.label.sequence for n in s.postorder() if not n.is_root())
+    s_labels = set(n.label.sequence for n in s.postorder() if not n.is_ua_node())
     s_ete_labels = set(
-        n.label.sequence for n in s_ete_as_dag.postorder() if not n.is_root()
+        n.label.sequence for n in s_ete_as_dag.postorder() if not n.is_ua_node()
     )
     assert (
         len(s_ete_labels - s_labels) < 1
@@ -87,7 +87,7 @@ def check_sankoff_on_dag(
     ), "Downward pass of Sankoff on dag did not yield expected score"
 
     assert (
-        dag.count_trees() == dag.copy().count_trees()
+        dag.count_histories() == dag.copy().count_histories()
     ), "Resulting DAG had invalid internal node assignments"
 
 
diff --git a/tests/test_disambiguate.py b/tests/test_disambiguate.py
index ceaf1c7..2c9cd88 100644
--- a/tests/test_disambiguate.py
+++ b/tests/test_disambiguate.py
@@ -193,20 +193,20 @@ def test_expand_ambiguities():
 
     for dag in dags:
         cdag = dag.copy()
-        print(cdag.count_trees())
+        print(cdag.count_histories())
         cdag.explode_nodes()
-        print(cdag.count_trees())
+        print(cdag.count_histories())
         cdag.trim_optimal_weight()
         cdag._check_valid()
-        print(cdag.count_trees())
+        print(cdag.count_histories())
         print(cdag.weight_count())
         checkset = {
             hdag.from_tree(tree, ["sequence"]).to_newick()
-            for cladetree in dag.get_trees()
+            for cladetree in dag.get_histories()
             for tree in disambiguate(cladetree.to_ete(features=["sequence"]))
         }
         print(len(checkset))
-        assert checkset == {cladetree.to_newick() for cladetree in cdag.get_trees()}
+        assert checkset == {cladetree.to_newick() for cladetree in cdag.get_histories()}
 
 
 #     newickset = {treeprint(tree) for tree in utils.disambiguate(tree2)}
diff --git a/tests/test_factory.py b/tests/test_factory.py
index 44db45b..b7f9f8e 100644
--- a/tests/test_factory.py
+++ b/tests/test_factory.py
@@ -79,7 +79,7 @@ def deterministic_newick_topology(tree: ete3.TreeNode) -> str:
 
 compdags = [dag.copy() for dag in dags]
 for dag in compdags:
-    dag.add_all_allowed_edges()
+    dag.make_complete()
 dags.extend(compdags)
 
 cdags = [dag.copy() for dag in dags]
@@ -91,12 +91,14 @@ def _testfactory(resultfunc, verify_func, collapse_invariant=False, accum_func=C
     for dag, cdag in zip(dags, cdags):
         # check dags
         result = resultfunc(dag)
-        verify_result = accum_func([verify_func(tree) for tree in dag.get_trees()])
+        verify_result = accum_func([verify_func(tree) for tree in dag.get_histories()])
         assert result == verify_result
 
         # check cdags
         cresult = resultfunc(cdag)
-        cverify_result = accum_func([verify_func(tree) for tree in cdag.get_trees()])
+        cverify_result = accum_func(
+            [verify_func(tree) for tree in cdag.get_histories()]
+        )
         assert cresult == cverify_result
 
         # check they agree, if collapse_invariant.
@@ -112,7 +114,7 @@ def test_valid_dags():
         for node in dag.postorder():
             for clade in node.clades:
                 for target in node.clades[clade].targets:
-                    assert target.under_clade() == clade or node.is_root()
+                    assert target.clade_union() == clade or node.is_ua_node()
 
         # each clade has a descendant edge:
         for node in dag.postorder():
@@ -133,7 +135,7 @@ def test_count_topologies():
                 features=[],
                 feature_funcs={},
             )
-            for tree in dag.get_trees()
+            for tree in dag.get_histories()
         }
         print(checkset)
         assert dag.count_topologies_fast() == len(checkset)
@@ -173,7 +175,7 @@ def test_copy():
     # Copying the DAG gives the same DAG back, or at least a DAG expressing
     # the same trees
     _testfactory(
-        lambda dag: Counter(tree.to_newick() for tree in dag.copy().get_trees()),
+        lambda dag: Counter(tree.to_newick() for tree in dag.copy().get_histories()),
         lambda tree: tree.to_newick(),
     )
 
@@ -253,17 +255,17 @@ def parsimony(tree):
     )
 
 
-def test_count_trees():
-    _testfactory(lambda dag: dag.count_trees(), lambda tree: 1, accum_func=sum)
+def test_count_histories():
+    _testfactory(lambda dag: dag.count_histories(), lambda tree: 1, accum_func=sum)
 
 
-def test_count_trees_expanded():
+def test_count_histories_expanded():
     for dag in dags + cdags:
         ndag = dag.copy()
         ndag.explode_nodes()
         assert (
-            dag.count_trees(expand_func=dagutils.sequence_resolutions)
-            == ndag.count_trees()
+            dag.count_histories(expand_func=dagutils.sequence_resolutions)
+            == ndag.count_histories()
         )
 
 
@@ -315,7 +317,7 @@ def test_valid_subtrees():
         for curr_dag_index in range(0, len(history_dag)):
             next_tree = history_dag[curr_dag_index]
             assert next_tree.to_newick() in history_dag.to_newicks()
-            assert next_tree.is_clade_tree()
+            assert next_tree.is_history()
 
 
 # this should check if the indexing algorithm accurately
@@ -334,7 +336,7 @@ def test_indexing_comprehensive():
         print("number of indexed trees: " + str(len(all_dags_indexed)))
         all_dags_indexed.remove(None)
 
-        # get the set of all actual dags from the get_trees
+        # get the set of all actual dags from the get_histories
         all_dags_true = set(history_dag.to_newicks())
 
         print("actual number of subtrees: " + str(len(all_dags_true)))
@@ -353,7 +355,7 @@ def test_indexing_comprehensive():
 def test_trim():
     for dag in dags + cdags:
         dag = dag.copy()
-        dag.add_all_allowed_edges()
+        dag.make_complete()
         dag._check_valid()
         dag.recompute_parents()
         dag._check_valid()
@@ -366,7 +368,7 @@ def test_trim():
 def test_from_nodes():
     for dag in dags + cdags:
         cdag = dag.copy()
-        cdag.add_all_allowed_edges()
+        cdag.make_complete()
         cdag.trim_optimal_weight()
         cdag._check_valid()
         wc = cdag.weight_count()
@@ -432,10 +434,10 @@ def edges(dag):
 def test_iter_covering_histories():
     for dag in dags + cdags:
         codag = dag.copy()
-        codag.add_all_allowed_edges()
+        codag.make_complete()
         trees = list(dag.iter_covering_histories())
         tdag = trees[0] | trees
-        tdag.add_all_allowed_edges()
+        tdag.make_complete()
         assert tdag.weight_count() == codag.weight_count()
 
 
diff --git a/tests/test_historydag.py b/tests/test_historydag.py
index 8086757..62801a5 100644
--- a/tests/test_historydag.py
+++ b/tests/test_historydag.py
@@ -95,12 +95,12 @@ def test_from_tree():
     return G
 
 
-def test_is_clade_tree():
+def test_is_history():
     tree = ete3.Tree(newickstring2, format=1)
     print(tree.sequence)
     dag = from_tree(tree, ["sequence"])
     dag._check_valid()
-    assert dag.is_clade_tree()
+    assert dag.is_history()
 
 
 def test_from_tree_label():
@@ -123,7 +123,7 @@ def test_preserve_attr():
         attr_func=lambda n: n.name,
     )
     dag._check_valid()
-    assert all(n.attr for n in dag.preorder(skip_root=True))
+    assert all(n.attr for n in dag.preorder(skip_ua_node=True))
 
     @utils.explode_label("sequence")
     def expand_func(seq):
@@ -136,10 +136,10 @@ def expand_func(seq):
 
     dag.explode_nodes(expand_func=expand_func)
     dag._check_valid()
-    assert all(n.attr for n in dag.preorder(skip_root=True))
+    assert all(n.attr for n in dag.preorder(skip_ua_node=True))
     dag.convert_to_collapsed()
     dag._check_valid()
-    assert all(n.attr for n in dag.preorder(skip_root=True))
+    assert all(n.attr for n in dag.preorder(skip_ua_node=True))
 
 
 def test_ete_newick_agree():
@@ -161,9 +161,9 @@ def test_ete_newick_agree():
     }
     viaetes = {
         from_tree(tree.to_ete(**outkwargs), **inkwargs).to_newick(**outkwargs)
-        for tree in dag.get_trees()
+        for tree in dag.get_histories()
     }
-    vianewicks = {tree.to_newick(**outkwargs) for tree in dag.get_trees()}
+    vianewicks = {tree.to_newick(**outkwargs) for tree in dag.get_histories()}
     assert viaetes == vianewicks
 
 
@@ -236,7 +236,7 @@ def test_sample():
     namedict = {(str(x),): x for x in range(5)}
     dag = history_dag_from_newicks(newicks, ["name"])
     for i in range(10):
-        assert dag.sample().is_clade_tree()
+        assert dag.sample().is_history()
     sample = dag.sample()
     sample._check_valid()
     return sample.to_graphviz(namedict=namedict)
diff --git a/tests/test_support.py b/tests/test_support.py
index 7bcfa6f..7950809 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -72,7 +72,7 @@ def test_node_counts():
         node2count = dag.count_nodes()
         for node in node2count.keys():
             ground_truth = sum(
-                [node in set(tree.postorder()) for tree in dag.get_trees()]
+                [node in set(tree.postorder()) for tree in dag.get_histories()]
             )
             # print(
             #     f"\t node2count[node] = {node2count[node]} \t ground_truth = {ground_truth}"
@@ -90,8 +90,8 @@ def test_collapsed_node_counts():
         for node in node2count.keys():
             ground_truth = sum(
                 [
-                    node in set([n.under_clade() for n in tree.postorder()])
-                    for tree in dag.get_trees()
+                    node in set([n.clade_union() for n in tree.postorder()])
+                    for tree in dag.get_histories()
                 ]
             )
             print(
@@ -109,7 +109,7 @@ def test_edge_counts():
 
         for parent, node in edge2count.keys():
             ground_truth = 0
-            for tree in dag.get_trees():
+            for tree in dag.get_histories():
                 for curr_parent in tree.postorder():
                     if curr_parent != parent:
                         continue