Determines the number of quartets that are consistent within pairs of trees.

```
SharedQuartetStatus(trees, cf = trees[[1]])
QuartetStatus(trees, cf = trees[[1]], nTip = NULL)
ManyToManyQuartetAgreement(trees, nTip = NULL)
TwoListQuartetAgreement(trees1, trees2)
SingleTreeQuartetAgreement(trees, comparison)
```

- trees
A list of trees of class

`phylo`

, with identically labelled tips.- cf
Comparison tree of class

`phylo`

. If unspecified, each tree is compared to the first tree in`trees`

.- nTip
Integer specifying number of tips that could have occurred in

`trees`

. Useful if comparing trees from different data sources that contain non-overlapping tips. If`NULL`

, the default, then trees are assumed to contain the same tips. If`TRUE`

, then a vector is generated automatically by counting all unique tip labels found in`trees`

or`cf`

.- trees1, trees2
List or

`multiPhylo`

objects containing trees of class`phylo`

.- comparison
A tree of class

`phylo`

against which to compare`trees`

.

`QuartetStatus()`

returns a two dimensional array. Rows correspond to the input trees; the first row will report a perfect match if the first tree is specified as the comparison tree (or if `cf`

is not specified). Columns list the status of each quartet:

- N
The total number of quartet

*statements*for two trees of*n*leaves, i.e. 2*Q*.- Q
The total number of quartets for

*n*leaves.- s
The number of quartets that are resolved identically in both trees.

- d
The number of quartets that are resolved differently in each tree.

- r1
The number of quartets that are resolved in tree 1, but not in tree 2.

- r2
The number of quartets that are resolved in tree 2, but not in tree 1.

- u
The number of quartets that are unresolved in both trees.

`ManyToManyQuartetAgreement()`

returns a three-dimensional array
listing, for each pair of trees in turn, the number of quartets in each
category.
`TwoListQuartetAgreement()`

returns a three-dimensional array listing,
for each pair of trees in turn, the number of quartets in each category.
`SingleTreeQuartetAgreement()`

returns a two-dimensional array listing,
for tree in `trees`

, the total number of quartets and the
number of quartets in each category.
The `comparison`

tree is treated as `tree2`

.

Given a list of trees, returns the number of quartet statements present in the
reference tree (the first entry in `trees`

, if `cf`

is not specified)
that are also present in each other tree. A random pair of fully resolved
trees is expected to share `choose(n_tip, 4) / 3`

quartets.

If trees do not bear the same number of tips, `SharedQuartetStatus()`

will
consider only the quartets that include taxa common to both trees.

From this information it is possible to calculate how many of all possible quartets occur in one tree or the other, though there is not yet a function calculating this; let us know if you would appreciate this functionality.

The status of each quartet is calculated using the algorithms of
Brodal *et al*. (2013) and Holt *et al*. (2014), implemented in the
tqdist C library (Sand *et al*. 2014).

`SharedQuartetStatus`

: Reports split statistics obtained after removing all tips that do not occur in both trees being compared.`ManyToManyQuartetAgreement`

: Agreement of each quartet, comparing each pair of trees in a list.`TwoListQuartetAgreement`

: Agreement of each quartet in trees in one list with each quartet in trees in a second list.`SingleTreeQuartetAgreement`

: Agreement of each quartet in trees in a list with the quartets in a comparison tree.

Brodal GS, Fagerberg R, Mailund T, Pedersen CNS, Sand A (2013). “Efficient algorithms for computing the triplet and quartet distance between trees of arbitrary degree.”

*SODA '13 Proceedings of the Twenty-Fourth Annual ACM-SIAM Symposium on Discrete Algorithms*, 1814--1832. doi: 10.1137/1.9781611973105.130 .Estabrook GF, McMorris FR, Meacham CA (1985). “Comparison of undirected phylogenetic trees based on subtrees of four evolutionary units.”

*Systematic Zoology*,**34**(2), 193--200. doi: 10.2307/2413326 .Holt MK, Johansen J, Brodal GS (2014). “On the scalability of computing triplet and quartet distances.” In

*Proceedings of 16th Workshop on Algorithm Engineering and Experiments (ALENEX) Portland, Oregon, USA*.Sand A, Holt MK, Johansen J, Brodal GS, Mailund T, Pedersen CNS (2014). “tqDist: a library for computing the quartet and triplet distances between binary or general trees.”

*Bioinformatics*,**30**(14), 2079--2080. ISSN 1460-2059, doi: 10.1093/bioinformatics/btu157 .

Use splits (groups/clades defined by nodes or edges of the tree) instead of quartets as the unit of comparison:

`SplitStatus()`

.Generate distance metrics from quartet statuses:

`SimilarityMetrics()`

.

Other element-by-element comparisons:
`CompareQuartetsMulti()`

,
`CompareQuartets()`

,
`CompareSplits()`

,
`PairSharedQuartetStatus()`

,
`QuartetState()`

,
`SplitStatus()`

```
data('sq_trees')
# Calculate the status of each quartet relative to the first entry in
# sq_trees
sq_status <- QuartetStatus(sq_trees)
# Calculate the status of each quartet relative to a given tree
two_moved <- sq_trees[5:7]
sq_status <- QuartetStatus(two_moved, sq_trees$ref_tree)
# Calculate Estabrook et al's similarity measures:
SimilarityMetrics(sq_status)
#> DoNotConflict ExplicitlyAgree StrictJointAssertions
#> move_two_near 0.9272727 0.9272727 0.9272727
#> move_two_mid 0.7636364 0.7636364 0.7636364
#> move_two_far 0.7212121 0.7212121 0.7212121
#> SemiStrictJointAssertions SymmetricDifference MarczewskiSteinhaus
#> move_two_near 0.9272727 0.9272727 0.8644068
#> move_two_mid 0.7636364 0.7636364 0.6176471
#> move_two_far 0.7212121 0.7212121 0.5639810
#> SteelPenny QuartetDivergence SimilarityToReference
#> move_two_near 0.9272727 0.9272727 0.9272727
#> move_two_mid 0.7636364 0.7636364 0.7636364
#> move_two_far 0.7212121 0.7212121 0.7212121
# Compare trees that include a subset of the taxa 1..10
library('TreeTools', quietly = TRUE, warn.conflict = FALSE)
QuartetStatus(BalancedTree(1:5), BalancedTree(3:8), nTip = 10)
#> N Q s d r1 r2 u
#> [1,] 420 210 0 0 5 15 190
# If all taxa studied occur in `trees` or `cf`, set `nTip = TRUE`
QuartetStatus(BalancedTree(1:5), BalancedTree(3:10), nTip = TRUE)
#> N Q s d r1 r2 u
#> [1,] 420 210 0 0 5 70 135
# Calculate Quartet Divergence between each tree and each other tree in a
# list
QuartetDivergence(ManyToManyQuartetAgreement(two_moved))
#> move_two_near move_two_mid move_two_far
#> move_two_near 1.0000000 0.6909091 0.6484848
#> move_two_mid 0.6909091 1.0000000 0.6484848
#> move_two_far 0.6484848 0.6484848 1.0000000
# Calculate Quartet Divergence between each tree in one list and each
# tree in another
QuartetDivergence(TwoListQuartetAgreement(sq_trees[1:3], sq_trees[10:13]))
#> m1mid_col1 m1mid_colsome m2mid_col1 m2mid_colsome
#> ref_tree 0.8303030 0.7439394 0.7515152 0.6893939
#> move_one_near 0.8545455 0.7681818 0.7272727 0.6651515
#> move_one_mid 0.9878788 0.9015152 0.6060606 0.5621212
```