- ancestor nodes
- On a
*tree*, the full set of*nodes*from which a given*node*has descended (i.e., the given node’s parent, parent’s parent, parent’s parent’s parent, and so on until the*root*or the*seed node*of the tree, inclusive). - basal

basal node - On a
*tree*, a*node*that is ancestral with respect to another node.*Leaf or tip nodes*can never be basal, except if the tree consists of only a single node (i.e., the*seed node*is a*leaf node*). The basal-most node of a tree is the*seed or root node*. - basal bifurcation
- On a
*tree*, a*seed or root*which has exactly two*child nodes*. On a*rooted tree*this (can) reflect actual information, but on an*unrooted tree*, this is actually an artifact, as the*seed or root*does not actually exist as it is just an algorithmic contrivance. In practical terms, this means that*bipartition*calculations and operations on*unrooted trees*with basal bifurcations may result in undetermined and errorenous behavior. Thus, typically, on unrooted trees the basal bifurcation is collapsed to yield a basal trifurcation. - basal trifurcation
- On a
*tree*, a*seed or root*which has exactly three*child nodes*. While this might occur in both*rooted*and*unrooted*trees, this is typically the result of*collapsing a basal bifurcation*on*unrooted trees*. - bifurcating tree
- A
*tree*in which all*nodes*are*bifurcating*. - bifurcation

bifurcating node - On a
*tree*, a*node*with exactly two*child nodes*. Also known as an “out-degree two” node. - bipartition

split - On a
*tree*, a partition of the leaf set of a tree into two mutually-exclusive and collectively-comprehensive subsets. It corresponds to an edge of a tree: if we imagine “splitting” or cutting a tree into two trees at a given edge, the leaf sets of each of the new trees form the two subsets of the partitioning. A bipartition is often referred to as a split, especially in the context of*unrooted trees*. Bipartitions are described in detail in the*DendroPy Primer*. - child node
- On a
*tree*, a*node*descending from another*node*. A node on a tree may have zero or more child nodes. A node with zero child nodes is termed a*leaf node*. - descendent nodes
- On a
*tree*, the full set of nodes that are descended from a given node (i.e., the given node’s children and children’s children and children’s children’s children, and so on, until the*leaf nodes*of the tree, inclusive). - edge

branch A connection between two

*nodes*on a*tree*, modeled in DendroPy by the`Edge`class. A synonym for “branch” in the context of phylogenetic trees.An edge connects a “tail node” (also called an origin or source node) to a “head node” (also called a target or destination node). The tail node is called the “

*parent*” of the head node, while the head node is called the “*child*” of the tail node.An edge is said to subtend or be incident to the node

*to*which an edge connects, i.e., the head node. Conversely, the edges connecting a node to its children are called outgoing edges with respect to the tail node.On a

*tree*, every node has one and exactly one incident edge, and every edge has a*head node*. On the other hand, not every node may have outgoing edges (e.g,*leaf nodes*), and not every edge has a*tail node*(e.g.,*root nodes*). As such, edges can be thought of “belonging” to their head nodes, due to this one-to-one relationship.Edges can have any number of properties or attributes associated with them, representing a diverse range of phenomena, but the most important one is the edge

*length or weight*.- edge length

edge weight - A (typically) quantitative value associated with an
*edge*. This value may represent any number of things, but most typically is used to model time, evolutionary distance, or expected rates of substitution on a phylogenetic tree. An*edge*may have many values, quantitative or otherwise, associated with it, but the length or weight is special as it usually denotes the relationship between the*tail node*and*head node*related by an*edge*. - head node

target node

destination node - On an
*edge*connecting two*nodes*, the node*to*which the edge extends to link*from*the other node, termed the*tail node*. The head node is the*child node*of the*tail node*, and the*tail node*is the*parent node*of the head node. The*edge*is said to subtend, or be incident, to the head node. - incident edge

subtending edge - An
*edge*that connects*to*a particular*node*is termed the incident or subtending edge of that node. - internal edge
- An
*edge*that has an*internal node*as a*head node*. - internal node
- A
*node*that has*child nodes*. Also known as an inner node or branch node. - leaf edge

terminal edge

external edge

outer edge - An
*edge*that has an*leaf node*as a*head node*. - leaf node

tip node

terminal node

external node

outer node - A
*node*that does not have any*child nodes*descending from it. Also known as a tip, outer node, external node, or terminal node. - node
- An fundamental element of information or data on a
*tree*, connected to other such elements in a parent-child relationshop by*edges*. In DendroPy, a node is modeled by the`Node`class. A node has at most one*parent*, to which it is connected by its*incident or subtending*edge. A node may have zero or more*children*, to each of which it is connected by an independent*outgoing edge*edge. A node can be associated with zero or more informational or data values. In a phylogenetic*tree*, one of these values is often a*taxon*, but many other aspects of information can be modeled. - node depth
- On a
*tree*, the depth of a node is the length of the*path*to its*root*(i.e., its root path). The root node has a depth zero. - node height
- The height of a node is the length of the longest downward path to a leaf from that node. The height of the root is the height of the tree. The depth of a node is the length of the path to its root (i.e., its root path). The root node has depth zero, leaf nodes have height zero, and a tree with only a single node (hence both a root and leaf) has depth and height zero. Conventionally, an empty tree (tree with no nodes, if such are allowed) has depth and height 1.
- outgoing edge
- An
*edge*that connects*from*a particular*node*(to, e.g., its*children*is said to be an outgoing edge for that node. - parent node

ancestor node - On a
*tree*, a*node*from which a given node immediately descends. - path
- The sequence of
*edges*connecting two*nodes*on a*tree*. - path length

path weight

unweighted path

weighted path - The number or sum of lengths of the
*edges*connecting two*nodes*on a*tree*. An*unweighted*path length is just the number of*edges:, while a *weighted* path length or path weight is the sum of :term:`edge lengths*. - postorder traversal
- A process by which all nodes of a tree are visited, with a particular node being visited only after its children.
- preorder traversal
- A process by which all nodes of a tree are visited, with a particular node being visited before its children.
- rooted tree
- A state of a
*tree*in which its*seed node*represents the most-recent common ancestor of all the*leaf nodes*on the tree. Rooted trees have a distinct directionality, and ancestor-descendent relationships are not invertible. - schema
- The format or syntax of serialized phylogenetic or related data.
Examples are NEXUS, NEWICk, Phylip, NeXML, etc. A “schema” is
DendroPy-speak for “format” (we cannot use the argument name “format”
because this is a Python built-in, and hence we adopted this
terminology for consistency), and is typicallly specified using one of
a set of predefined string values, known as “schema specification
strings”. Supported reading (input) schemas are described
*here*while supported writing (output) schemas are described*here*. - seed node

root node The first or topmost

*node*in a tree. This is also more commonly called the “root” or “root node” of the tree, though, in the strictest sense, this equivalence is only valid when the tree is explicitly*rooted*. Both*rooted trees*and*unrooted trees*have seed nodes. In rooted trees, the seed node is the root of the tree.By definition, the seed node does not have a

*parent node*. It is the node at which algorithms on the tree begin, since as a data structure, one can only pass from*parent node*to*child nodes*. If the tree is*rooted*, then the seed node is equivalent to the root of the tree.- sibling node

sister node - Two or more
*nodes*that share the same*parent node*, i.e., are descended from the same node, are said to be siblings or sisters with respect to each other. - subtree
- A subtree of a
*tree*is a tree consisting of a*node*in the tree and all its*descendents*. Each*node*on a*tree*thus corresponds to the*root*of the subtree that it determines. - tail node

source node

origin node - On an
*edge*connecting two*nodes*, the node*from*which the edge extends to link*to*the other node, termed the*head node*. The tail node is the*parent node*of the*head node*, and the*head node*is the*child node*of the tail node. The edge is said to be an outgoing node with respect to the tail node. - taxon

operational taxonomic unit

taxon concept

taxon name - A class of organisms being modeled represented by a string label or
namethat is guaranteed to be unique within a particular
*taxon namespace*. - taxon namespace
- A set of distinct and unique labels, with each label mapping to one and
exactly one or names that is used to relate data from across different
data sources to each other by reference to a
*taxon concept*. - tree

arborescence A tree is a set of

*nodes*connected to each other in parent-child relationships given by a set of*edges*. In DendroPy, a tree is modeled by the`Tree`class. A tree is a specialization of a graph, constrained such that:- All its
*edges*are directional. - It has no directed cycles .
- The directionality is from the
*root*(or “*seed node*” in DendroPy’s parlance) to the*tips*.

The first and second constraints alone result in a directed acylic graph . The addition of the third constraint results in an arborescence, which is strictly synonymous with “tree”.

- All its
- unifurcation

unifurcating node - On a
*tree*, a*node*with exactly one*child node*. Also known as an “out-degree one” node. In some cases, unifurcations may be used to represent information (e.g., a change in some value associated with edges, such as population size or a rate of some kind), but they more typically arise as side-effect of tree manipulation operations, such as re-rooting or pruning. Though DendroPy has no problem in handling unifurcations, trees with unifurcating nodes are considered pathological in many contexts and operations, and DendroPy thus provides facilities for suppressing unifurcations, either on existing trees or as they occur as a side-effect of other operations. - unrooted tree
- A state of a
*tree*in which its*seed node*is an algorithmic artifact, and not necessarily represents the most-recent common ancestor of all the*leaf nodes*on the tree. In an unrooted trees, ancestor-descendent relationships are also algorithmic artifacts and can be (conceptually) inverted without changing the information represented by the tree, though this operation usually requires a fundamental restructuring of the computational representation of the tree.