© D. Swofford.
This help system is provided as a quick reference guide to the commands and options 
available in PAUP.  It is not intended as a substitute for the User's Manual, which should 
be consulted for more detailed information.

To enter the help system, choose "Help" from the Windows Menu or System 7 Help menu 
(or press command-/) or press the "?" button at the top right corner of any dialog box.  The 
help window, containing two scrollable windows, will appear.  The bottom window 
contains a list of available topics and the top window shows the help text for the selected 
topic.  If you want help on a different topic, simply click on a different item in the topics 
list.  Use the appropriate scroll bar to see additional topics or to scroll through the help text.  
Note that when a "?" button is used to request help, the initial topic is context-sensitive.  
E.g., if you press a help button while the "Describe Trees" dialog is active, you will get a 
description of the use of this command.
Available character types are ordered (Wagner), unordered (Fitch), Dollo, irreversible 
(Camin-Sokal), and user-defined.  A brief discussion of these types is provided in the 
following screens; refer to the Users Manual for a more complete discussion.
"Ordered" characters are those typically associated with the "Wagner method."  The 
character states are ordered according to their position in the symbols list specified in the 
FORMAT statement of the DATA block.  (If a symbols list is not explicitly provided, it 
defaults to "01".)

The list of symbols represents a linear transformation series.  For example, if you specified 
SYMBOLS="0123" in the FORMAT statement, PAUP treats ordered characters under the 
assumption that to get from state 0 to state 3, the character must proceed progressively 
through states 1 and 2.  Similarly, if SYMBOLS="ABCQ", state B lies between A and C, 
and state C lies between B and Q.  Remember that no direction is implied by the symbols 
list, however.  For example, all of the following transformations are consistent with the 
symbols list "012"; there is no requirement that '0' be the ancestral state:

        0 -> 1 -> 2

        2 -> 1 -> 0

        0   2
         \ /
          1
Unordered characters are defined such that any state is capable of transforming directly to 
any other state.  Character-state assignments are made to interior nodes of the tree so as to 
minimize the total number of character-state transformations (steps), using an algorithm 
based on Fitch's method for nucleotide sequence data.
A "Dollo" character is one that is consistent with the requirement that every derived 
character state be *uniquely* derived.  If a hypothetical ancestor is included in the analysis, 
this definition corresponds to the traditional Dollo model in which each character state is 
allowed to originate only once during evolution and all homoplasy takes the form of 
reversals to a more ancestral condition (i.e., parallel gains of the derived condition are not 
allowed).

As for ordered (Wagner) characters, character states are linearly ordered according to their 
position in the symbols list specified in the FORMAT statement of the DATA block.  
However, we now define a "forward transformation" as a change from a less derived state 
to a more derived state, and a "backward transformation" as a change from a more derived 
state to a less derived state.  See "direction of transformations" for further explanation of 
"derived" vs. "ancestral" states.
PAUP (as well as MacClade) differs from some other implementations of Dollo parsimony 
in that it can operate as an unrooted method.  Loosely, this means that the program simply 
enforces the requirement that all derived character states be homologous.

More formally, the unrooted Dollo model forces us to assign character states to the interior 
nodes of the tree such that if a path is traced from any terminal taxon to any other, there is 
never a transformation from a more derived state to a less derived state and back again.  
(Remember that a transformation from any state to any other state implies transformations 
through intervening states according to the SYMBOLS list.)

Under this definition, the position of the root affects neither the assignment of character 
states nor the length of the tree.  For example, both of the trees below, which differ only in 
the placement of the root, require two steps under the unrooted Dollo model, assuming that 
state 1 is the derived state.

     A   B   C   D        A   B   C   D
     0   1   1   0        0   1   1   0
      \ /   /   /          \ /     \ /
       1   /   /            1       1
        \ /   /              \     /
         1   /                \   /
          \ /                  \ /
           0                    1

That is, neither tree requires more than a single origination of state 1.  (In the tree on the 
right, the derived state (1) is assumed to be ancestral with respect to the group ABCD, but 
derived relative to some more inclusive group.)

If, on the other hand, the trees are rooted by the attachment of a hypothetical ancestor 
possessing state 0, the left tree will be shorter (2 steps) than the right tree (3 steps):

     A   B   C   D        A   B   C   D
     0   1   1   0        0   1   1   0
      \ /   /   /          \ /     \ /
       1   /   /            1       1
        \ /   /              \     /
         1   /                \   /
          \ /                  \ /
           0                    1
            \                    \
             0                    0

This is because we now have to include the initial gain of state 1 in the tree length.  This 
example makes it clear that trees computed under Dollo parsimony are intrinsically rooted 
only if we assume we know the state at the "outgroup node".
There are three options for specifying the direction of "forward" vs. "backward" 
transformations.  If an ancestor is *not* included in the search (the default), polarity is 
either "up" or "down".  "Up" specifies that states higher in the symbols order are derived 
relative to states lower in the symbols order.  "Dn" specifies the opposite-- higher ordered 
states are ancestral to lower ordered states.   If an ancestor is included in the analysis, the 
state defined in the ancestor defines the most ancestral state, with both lower and higher 
ordered states in the SYMBOLS list being relatively more derived.   Note that if the 
'standard' ancestor is in effect,  this state will be "missing".

Within a file or from the command line, these options are specified by optionally appending 
a suffix to the "Dollo" keyword.  If no suffix is provided ('dollo'), then "up" is assumed.  
'Dollo.up' and 'dollo.dn' can be used to explicitly request the "up" and "dn" options, 
respectively.  In versions of PAUP that provide a menu mode, pop-up menus may be used 
to choose one of the options (see the user interface section for further information).
Irreversible characters are equivalent to ordered characters with the additional constraint of 
irreversibility being imposed (sometimes referred to as the "Camin-Sokal" model).  As for 
ordered (Wagner) characters, character states are linearly ordered according to their position 
in the symbols list specified in the FORMAT statement of the DATA block.  However, we 
now prohibit transformations from a more derived state to a less derived state.  See 
"direction of transformations" for further explanation of "derived" vs. "ancestral" states.

Although character transformations must always proceed in the direction of a more derived 
state, they need not proceed in a single direction with respect to the SYMBOLS list.  For 
example, if SYMBOLS="01234" has been specified and the ancestral state is '2', both 2 -> 
1 -> 0 and 2 -> 3 -> 4 transformation sequences are permitted.

If the ancestor is coded as missing for an irreversible character, PAUP determines the most 
parsimonious assignment of an ancestral character state that is consistent with the 
irreversibility requirement.
There are three options for specifying the direction of "forward" vs. "backward" 
transformations.  If the ancestral state defined by the current ancestor is not "missing", then 
this state represents the most ancestral state, with both lower and higher ordered states in 
the SYMBOLS list being relatively more derived.   If an ancestor *is* "missing",  then the 
polarity is either "up" or "down".  "Up" specifies that states higher in the symbols order are 
derived relative to states lower in the symbols order.  "Dn" specifies the opposite-- higher 
ordered states are ancestral to lower ordered states.   Note that if the 'standard' ancestor is 
in effect,  all states will be "missing", and the "up"/"dn" setting determines the polarity.

Within a file or from the command line, these options are specified by optionally appending 
a suffix to the "irrev" keyword.  If no suffix is provided ('irrev'), then "up" is assumed.  
'Irrev.up' and 'irrev.dn' can be used to explicitly request the "up" and "dn" options, 
respectively.  In versions of PAUP that provide a menu mode, pop-up menus may be used 
to choose one of the options (see the user interface section for further information).
Two kinds of user-defined character types are available.  Stepmatrices allow you to define 
arbitrary character types by specifying the distance from any character state to any other.  
Character-state trees provide an easy method for inputting branching character 
transformation series.  See the following screens for more information.
A stepmatrix is a square matrix specifying the distance from every character state to every 
other state.  These distances represent the "cost" in tree length units of the corresponding 
transformations.  (Transformations may be completely forbidden by coding 'i', for infinity, 
as the transformation cost.)  For each stepmatrix character, PAUP uses algorithms based 
on the work of David Sankoff to determine the minimum possible length on each tree it 
evaluates, and to reconstruct hypothetical ancestors consistent with this length.

Stepmatrices may be used to define models of character transformation that cannot be 
expressed under any other available coding method.  For instance, "partially unordered" 
characters may be constructed by including loops in the graph of character-state 
relationships.  Also, "partial irreversibility" can be obtained by using an asymmetric matrix.  
For these and other examples, refer to the User's Manual.

Most of the other standard types may be defined equivalently as stepmatrices.  For 
example, the stepmatrices

   -   1   2         -   1   1              -   1   2
   1   -   1   ,     1   -   1  , and       i   -   1
   2   1   -         1   1   -              i   i   -

correspond to the "ordered", "unordered", and "irreversible" types, respectively, for a 
character with 3 states.  However, stepmatrix characters require significantly more 
computation than other character types, and should be used only if it is not possible to use 
one of the standard types.

See "The ASSUMPTIONS block" for details on how to define a stepmatrix in an input file.
Character-state trees are used to specify a non-linear, branching, relationship among 
character states, which are then otherwise treated as ordered characters.  (Formally, a 
character-state tree imposes a "partial order" on the character states.)  In most earlier 
programs, users were required to recode character-state trees using additive coding (binary 
or otherwise; see below).  PAUP now provides this capability automatically.

As an example, suppose that you wish to assume that states C and D were derived 
independently from state B, which itself was derived from state A.  The following 
character-state tree would be used to represent this relationship:

                        C     D
                         \   /
                          \ /
                           B
                            \
                             \
                              A

Either of the following codings, breaking the character into a suite of independent 
characters, could be used in lieu of a character-state tree:

            A = 00             A = 000
            B = 10             B = 100
            C = 20             C = 110
            D = 11             D = 101

However, such a coding makes interpretation of the output more difficult since you would 
have to decode the new characters back to the original states of the character-state tree.  In 
this case, the character-state tree specification "((c,d)b)a" provides an equivalent definition 
of the character, requires essentially identical computation time, and eliminates the coding-
decoding steps.

Characters defined as character-state trees are fully reversible, however they may evolve 
only along the paths specified by that definition.  For instance, in the above example a 
change from state C to state D would imply passage through state B and would require two 
steps.

In unusual situations, you may want to use character-state trees to define a linearly ordered 
character with an ordering different from that implied by the SYMBOLS list.  For example, 
if SYMBOLS="012" and you want a character to be ordered as 0-2-1 rather than 0-1-2, 
you could declare a user-defined type with the character-state tree specification "((1)2)0".  
Other ordered characters would retain the 0-1-2 ordering.

Finally, remember that character-state trees, like linearly ordered characters, are undirected.  
The character-state tree only specifies available paths for character-transformation.  In the 
example above, state C could just as easily have been placed at the base as shown below:


                        A     D
                         \   /
                          \ /
                           B
                            \
                             \
                              C

See "The ASSUMPTIONS block" for details on the specification of character-state trees in 
an input file.
Ancestral states are used in PAUP for four purposes.  First, some character types, 
including irreversible and asymmetric stepmatrix characters, automatically cause a 
hypothetical ancestor to be included in the analysis; the ancestral states assign a state to this 
ancestor for each character.  Second, Dollo and irreversible characters require information 
on character polarity that is used to define the nature of "forward" and "backward" 
transformations.
Third, even when it is not required, you may choose to include an ancestral taxon in a 
search.  In  this case, the trees computed during the search are automatically rooted at the 
point where the ancestor connects to the tree.  Finally, if you input user-defined trees as 
rooted trees, character states must be assigned to the ancestor of the full tree.

Ancestral states are defined by an ANCSTATES statement in the ASSUMPTIONS block.  
In addition to user-defined ANCSTATES settings, a "standard" ANCSTATES definition is 
defined as "missing" for all characters.

Any number of ANCSTATES settings may be defined (via multiple ANCSTATES 
statements), but only one is in effect at any one time.

See "The ASSUMPTIONS block" for details on the ANCSTATES statement.
Topological constraints are a new feature in version 3 of PAUP.  They are of two types: 
"monophyly" constraint trees, which contain all of the taxa in the data matrix, and 
"backbone" trees, which contain a subset of taxa.  To search under constraints, you must 
define and select a constraint tree; this tree is used to restrict the set of trees retained by 
heuristic or exact searches.

"Monophyly" constraint trees
Monophyly constraint trees are usually incompletely resolved (i.e., contain one or more 
polytomies).  These polytomies on the constraint tree indicate uncertainty with respect to 
relationships rather than simultaneous divergence into more than two descendant lineages.  
A tree being evaluated (the "trial tree") is said to be compatible with the constraint tree if 
and only if it is either identical to the constraint tree or it can be transformed into the 
constraint tree by deleting (collapsing) one or more of its branches.  In more biological 
terms, constraint-tree compatibility means that any statement of relationship among taxa 
implied by the constraint tree must also be true for the trial tree.  Thus, trial trees compatible 
with the constraint tree are (usually) "more highly resolved versions" or "refinements" of 
the constraint tree.

If a group of particular interest is not monophyletic on the minimal trees for your data set, 
constraining a search so that only those trees consistent with the group's monophyly are 
retained makes it easy to determine how much longer are the shortest trees on which the 
group is monophyletic. 

In addition to allowing you to force compatibility with the constraint tree, PAUP allows 
you to request acceptance of trees only if they are incompatible with the constraint tree.  
This information provides a crude index to the strength of support for a clade.  Of course, 
you are then faced with the decision as to how many steps longer a tree must be before it 
the existence of a clade is considered to be insupportable. 

Note that although constraint trees are input as rooted trees, the criterion for satisfaction of 
topological constraints is the same whether rooted or unrooted trees are being determined.  
For unrooted trees, the rooted constraint tree is first "derooted."  Then each tree being 
evaluated is compared to the (unrooted) constraint tree; if the trial tree is equal to the 
constraint tree or the trial tree can be converted to the constraint tree by deleting one or more 
branches from the trial tree, then the constraints are satisfied. 

Yet another use of topological constraints is to enforce ingroup monophyly or partial 
outgroup structure.  Recall that when potential outgroup taxa vary for characters that are 
informative with respect to ingroup relationships, one recourse is to include several 
outgroup taxa in the analysis.  In this procedure, the ingroup node incident to the branch 
partitioning the ingroup from the outgroup becomes the root of the ingroup portion of the 
tree.  If, however, the ingroup and outgroup taxa do not constitute a partition on the most 
parsimonious tree(s), you may wish to impose  ingroup monophyly as a constraint.  
(Presumably, you would do this only if additional evidence supporting ingroup monophyly 
exists, but is not contained in the data set.)  

Finally, note that if you use the option to collapse zero-length branches (see "Zero-Length 
Branches and Polytomies," below) PAUP will not collapse a branch if this action would 
result in violation of the constraints for a tree that would otherwise satisfy them.

"Backbone" constraint trees
"Backbone" constraint trees differ from "monophyly" trees in that they contain only a 
subset of the study taxa.  A trial tree is compatible with the constraint tree if pruning the 
taxa not present on the backbone tree from the trial tree  leaves a topology identical to the 
backbone.  Unlike the monophyly constraint trees described above, backbone trees force a 
relative topology, and other taxa may be added at any point on the backbone tree, as long as 
the backbone is not violated.

Using backbone constraints is less restrictive than using monophyletic constraints, in that 
any topology is compatible with the constraint tree as long as the relative backbone 
topology is preserved.   This means that a backbone does not force an inclusive 
monophyletic group as does a monophyly constraint tree. 

Either type of constraint tree may be used (enforced) during searching and tree filtering 
operations. 
Input files for PAUP are standard text files containing commands and/or data.  The 
following screens describe the formatting of these files.
The NEXUS format is a common-file format designed to facilitate the interchange of input 
files between programs used in phylogeny and classification.  Data files that conform 
strictly to the NEXUS guidelines can be input to any program that fully supports the 
NEXUS standard.  (Currently, these programs are limited to PAUP and to Wayne and 
David Maddison's MacClade, but we hope to encourage others to adopt the format as 
well.)  Among other things, this means that data files created using MacClade's spreadsheet 
editor can be input to PAUP, and PAUP tree and data files can be input to MacClade for 
further analysis.

The characteristic of NEXUS files that allows them to be so portable is the "block" 
concept.  A "block" is a well-defined subsection of an input file that can either be read or 
ignored by a NEXUS-conforming program.  The format of three blocks, "DATA", 
ASSUMPTIONS", and "TREES" is defined by the standard; any conforming program 
must either ignore these blocks entirely or be able to interpret statements in the block as 
defined by the standard.

Other blocks are program-specific.  If a program encounters a block that it either does not 
recognize or does not want to deal with, it simply skips over the entire block.  (Of course, 
this makes it extremely important to spell block names correctly; otherwise, essential blocks 
might be unintentionally skipped over during processing.

Every block starts with "BEGIN blockname;" and ends with "ENDBLOCK;".  Each block 
is composed of one or more statements, each terminated by a semicolon (;).  If a statement 
within a block is unrecognized, a warning message is issued and it is then ignored by 
skipping forward to its terminating semicolon.  (Optionally, PAUP will abort processing of 
a file if an unrecognized statement is encountered.)

Comments may be included in NEXUS files by enclosing them within square brackets, as 
in "[This is a comment]."  The first character following the opening square bracket may 
have special meaning.  In PAUP, if the first comment character is an exclamation point (!), 
as in "[!Please output this comment.],"the comment is treated as an "output" comment -- it 
will be directed to all current output destinations (display window, output file, and/or 
printer).

NEXUS-conforming files are identified by a "#NEXUS" directive at the very beginning of 
the file (line 1, column 1).  If the #NEXUS is omitted PAUP issues a warning but 
continues processing.  (The standard does not specify the behavior of a program when the 
"#NEXUS" is omitted; it is best to just always include it.) 

NEXUS files are entirely free-format.  Blanks, tabs, and newlines may be placed anywhere 
in the file.  Unless RESPECTCASE is requested, commands and data may be entered in 
upper case, lower case, or a mixture of upper and lower case.  If RESPECTCASE is 
requested, case is considered significant in character-state symbols and in tags for 
assumption sets, ancstates specifications, etc.

The following conventions are used in the syntax descriptions of the various blocks.  
Upper-case items are entered exactly as shown.  Lower-case items inside of angle brackets 
-- e.g.,  -- represent items to be substituted by the user.  Items inside of square 
brackets -- e.g., [X] -- are optional.  Items inside of curly braces and separated by vertical 
bars -- e.g.,  { X | Y | Z } -- are mutually exclusive options.  An item followed by an 
ellipsis (...) means that it may be repeated one or more times.

The following screens provide a brief description of the NEXUS input format.  For 
complete details regarding the format of NEXUS input files, refer to the User's manual.
The DATA block contains the data matrix and other associated information.  It can contain 
the following commands: DIMENSIONS, FORMAT, OPTIONS, CHARLABELS, 
TAXLABELS, STATELABELS, and MATRIX. Its syntax is:

BEGIN DATA [block-name] ;
     DIMENSIONS NTAX=number-of-taxa NCHAR=number-of-characters;
     [ FORMAT
          [ MISSING=missing-symbol ]
          [ LABELPOS={ LEFT | RIGHT } ]
          [ SYMBOLS="symbols-list" ]
          [ INTERLEAVE ]
          [ MATCHCHAR=match-symbol ]
          [ EQUATE="...]" ]
          [ TRANSPOSE ]
          [ RESPECTCASE ] 
          [ DATATYPE = {STANDARD | DNA | RNA | PROTEIN} ]
          [ GAP=gap-symbol ] ; ]
     [ OPTIONS
          [ IGNORE={ NONE | INVAR | UNINFORM } ]
          [ MSTAXA = { UNCERTAIN | POLYMORPH } ]
          [ ZAP = "character-list" ] 
          [ GAPMODE = { MISSING | NEWSTATE } ] ; ]
     [ CHARLABELS character-name ...  ; ]
     [ TAXLABELS taxon-name ...  ; ]
     [ STATELABELS charnum-and-state-list [ , charnum-and-state-list ] ... ; ]
     MATRIX data-matrix ;
ENDBLOCK;

The commands and their options are:

CHARLABELS character-name
Use the CHARLABELS command if you want to define alphanumeric character names to 
supplement the default numeric identifiers.  The syntax is:

     CHARLABELS character-name-list;

The character-name-list  is of the form

     character-name1 character-name2 ...

where each character-namei is a valid character identifier for the ith character (see 
"Identifiers" above).  The underscore (_) character can be used as a placeholder if you do 
not want to assign names to some characters.  It is permissible to supply fewer than 
NCHAR names; the remaining characters will then be identified by number only.  The 
length limit on these labels is 10 characters, due to line-length constraints in PAUP output.  
However, on input, the full character label is needed.  Any CHARLABELS command 
issued from the command line overrides labels provided in the data matrix. 

DIMENSIONS
The DIMENSIONS command specifies the size of the data matrix.  The syntax is:

     DIMENSIONS NTAX= number-of-taxa NCHAR= number-of-characters;

where number-of-taxa and number-of-characters are integer values.  Technically, the limits 
on numbers of taxa and characters is 32767 but practical limitations on computing time and 
available memory will reduce the maximum numbers of taxa and characters that can be 
accommodated.

FORMAT
The FORMAT command is used to specify information pertaining to the format of the data 
file.  The syntax is:

     FORMAT option-specification ... ;

Any or all of the following option specifications may be given:

MISSING=missing-symbol
The missing-symbol specifies a character used to represent missing data.  Any alphabetic, 
numeric, or other character that may be used as a character-state symbol may be used as the 
missing-symbol.  If MISSING is not specified, it defaults to '?'.

TRANSPOSE
If TRANSPOSE is specified, rows of the data matrix correspond to characters and columns 
correspond to taxa.  Otherwise, rows correspond to taxa and columns to characters.

LABELPOS={ LEFT | RIGHT }
If LABELPOS=LEFT, taxon names (or character names, if the data matrix is transposed) 
begin each row of the data matrix (i.e., precede the character-state data).  If 
LABELPOS=RIGHT, then these names end each row of the data matrix.  The default is 
LABELPOS=LEFT.

SYMBOLS="symbols-list"
The SYMBOLS list defines a set of permissible symbols that may be used to designate 
character states.  The default SYMBOLS list is "01" for the STANDARD data type (see 
below), which means that the only (non-missing) character-state symbols permitted are '0' 
and '1'.  If you want to use any other symbols to designate character states, you must 
explicitly define an alternate SYMBOLS list.  The standard symbols for molecular sequence 
types (DNA, RNA, PROTEIN) are given in the section "Predefined formats for molecular 
sequence data" (Chapter 2).
The format of a symbols-list is a sequence of single-character "symbols"; the entire list is 
then enclosed within double-quotes. 

INTERLEAVE
If INTERLEAVE is not specified, the character-state data are entered sequentially by taxon 
(i.e., all character-state data for the first taxon are entered before beginning the second 
taxon, and so on).  Specification of INTERLEAVE allows the data to be entered in 
"blocks" of characters.  This format is often used for nucleotide and amino-acid sequence 
alignments, but may be useful in other contexts as well.

MATCHCHAR=match-symbol
If a match-symbol is specified, any occurrence of that symbol in the data matrix is 
translated to the state (or state-set) occurring in the first row of the matrix.

EQUATE= "symbol=expansion..."
The EQUATE option provides a simple macro facility for translating character-state 
specifications in the data matrix to alternate character-state specifications.  The symbol 
component must be a single-character.  Expansion is either a valid character-state or a 
character-state set .
Any number of EQUATE macros may be specified following the equal sign, but only one 
pair of double-quotes is used.  For example:

    format equate="U=T R={AG} .=- X=?";

EQUATE macros may not be defined recursively.  That is, you cannot equate A to B and B 
to C, expecting A to be expanded to C.  If you equate the same symbol to more than one 
expansion,  the last definition applies.

RESPECTCASE
By default, PAUP does not distinguish between upper- and lower-case character-state 
symbols in the data matrix.  If you want upper- and lower-case representations of the same 
alphabetic character to refer to different character states, specify RESPECTCASE.

DATATYPE = { STANDARD | DNA | RNA | PROTEIN }
If DATATYPE=STANDARD, the SYMBOLS list is taken from the 
SYMBOLS="symbols-list" item, above (default = "01").  If DATATYPE is set to one of 
the molecular sequence types, a predefined SYMBOLS list is used ("ACGT" for DNA, 
"ACTU" for RNA, and the standard one-letter amino acid codes for PROTEIN).  In 
addition, standard ambiguity codes are implemented by predefined EQUATE macros.  See 
"Predefined formats for molecular sequence data" in Chapter 2 for more information on 
these types.

GAP=gap-symbol
The "gap symbol" refers to the symbol used to represent alignment gaps, corresponding to 
insertions and/or deletions.  For example, gap=- would assign the hyphen as the gap 
character.  The GAP setting is ignored unless DATATYPE is DNA, RNA, or PROTEIN.
Alignment gaps may be treated either as missing data or as an additional character-state 
(fifth base or 21st amino acid) using the GAPMODE option (see the OPTIONS command 
below).


MATRIX
The MATRIX command defines the data matrix.  The syntax is:

     MATRIX data-matrix ;

The form of the data-matrix depends on the options specified in the FORMAT command of 
the DATA block; see "The DATA Block" in Chapter 2 for details.


OPTIONS
The OPTIONS command of the DATA block is used to set certain options pertaining to the 
treatment of  the data matrix.  The syntax is:

     OPTIONS option-specification ... ;

Any or all of the following option specifications may be specified.

IGNORE={ NONE | INVAR | UNINFORM }
If IGNORE=NONE , all characters in the data set are used.  If INVAR or UNINFORM  
are specified, invariant ("constant") and uninformative characters, respectively, are 
ignored.  

MSTAXA = { UNCERTAIN  |  POLYMORPH }
If MSTAXA=UNCERTAIN, multistate taxa (i.e., nonsingleton character-state sets in 
terminal taxa) are interpreted as representing uncertainty about the state found in the taxon.  
If MSTAXA=POLYMORPH, multistate taxa are interpreted as polymorphism within the 
terminal taxon.  
Note that MacClade allows MSTAXA=VARIABLE as a third possibility.  PAUP does not 
support this option.  If you do not explicitly set MSTAXA, MacClade uses the uncertainty 
interpretation if the character-state set is enclosed in curly braces and the polymorphism 
interpretation if the set is enclosed between parentheses.  If you set MSTAXA here, this 
setting will override the interpretation implied by the curly brace vs. parenthesis notation in 
MacClade.

ZAP = "character-list"
All characters in the character-list will be ignored.

GAPMODE = { MISSING | NEWSTATE }
If GAPMODE=MISSING, gap characters in sequence data are treated as "missing."  If 
GAPMODE=NEWSTATE, gap characters are treated as a fifth base or 21st amino acid. If 
you are satisfied with the defaults indicated above and you do not want to "zap" characters, 
then you do not need to include an OPTIONS command.

STATELABELS
The STATELABELS command is recognized but not interpreted by PAUP.  In MacClade, 
it supplies names for the character-states of each character. 

TAXLABELS
Use the TAXLABELS command to supply taxon names when the data matrix is entered in 
transposed format.  The syntax is:

     TAXLABELS taxon-label1 taxon-label2 ... taxon-labelNTAX ;

If the data matrix is transposed and you do not provide a TAXLABELS command, the 
integers 1 through NTAX will be used to identify taxa in both input and output.  The length 
limit on these labels is 16 characters, although up to 31 characters may included in 
graphical tree output.  This is due to line-length constraints on PAUP output.  Any 
TAXLABELS command issued from the command line overrides any labels provided in 
the matrix. MacClade ignores TAXLABELS unless the data matrix is transposed.
The ASSUMPTIONS block is used to declare character types, assumption sets, and 
ancestral states.  Its syntax is:

    BEGIN ASSUMPTIONS;
        [ OPTIONS  [ DEFTYPE= ]
                   [ POLYTCOUNT={ MINSTEPS | MAXSTEPS } ]
                   [ POLYMCOUNT= [NO]ADDSTEPS ] ; ]
        [ USERTYPE  [ { STEPMATRIX | CSTREE } ] =  ; ]
        [ CHARSET  =  ; ]
        [ TYPESET [*]  = :
                              [ , : ...] ; ]
        [ WTSET [*]  = :
                              [ , : ... ] ; ]
        [ EXSET [*]   =  ; ]
        [ ANCSTATES [*]  = :
                              [ : ...] ; ]
     ENDBLOCK;

The commands used in the ASSUMPTIONS block are as follows:

ANCSTATES
Use the ANCSTATES command to define a set of ancestral states corresponding to an 
ancestral taxon.  The syntax is:

     ANCSTATES [*] ancestor-name = character-state : character-list
          [ , character-state : character-list ] ... ;

Any number of character-state:character-list pairs, separated by commas, may be specified.  
You may also repeat the ANCSTATES command to define multiple ancestors, although 
only one ancestor can be in effect at any given time.  If you precede the ancestor-name with 
an asterisk, that ancestor becomes the "current" ancestor.  You can also assign the current 
ancestor with the ASSUME command or the Choose Assumption Sets menu command.

ANCSTATES can also be used to explicitly specify the state for each character in the 
ancestor.  This is done using the VECTOR format option, e.g., if NCHAR=5, then
     ANCSTATES name VECTOR = 0 1 2 0 2;
would define an ancestor "name" with the specified states for the five characters.  

CHARSET
Use the CHARSET command to define a "character set."  Character sets are simply groups 
of characters that can be referred to by a single name in other commands.  The syntax is:

     CHARSET character-set-name = character-list ;

The character-set-name  must not be identical to any of the original character names.

EXSET
Use the EXSET command to define an "exclusion set."  The syntax is:

     EXSET [*]  exclusion-set-name = character-list ;

If you precede the exclusion-set-name with an asterisk, any previously excluded characters 
are re-included and the characters specified by character-list are excluded.  Otherwise, the 
exclusion set is simply defined for later use by the ASSUME command or the Include-
Exclude Characters and Choose Assumption Sets menu command.

OPTIONS
Use the OPTIONS command of the ASSUMPTIONS block to specify certain assumptions-
related options recognized by PAUP and by other NEXUS-conforming programs.  The 
syntax is:

     OPTIONS option-specification [option-specification]... ;

The only option used by PAUP is the following:
     DEFTYPE=character-type
The character-type specifies the character type that applies to characters not explicitly 
assigned a type by CTYPE and/or CHARSET commands.  It must be one of the standard 
types (ORD, UNORD, DOLLO, DOLLO.UP, DOLLO.DN, IRREV, IRREV.UP, or 
IRREV.DN).

The following option is used by MacClade but ignored by PAUP:
POLYTCOUNT = { MINSTEPS | MAXSTEPS }
This option specifies whether polytomies are treated as "hard" or "soft" when counting the 
number of steps required by a character and when reconstructing ancestral states.  PAUP 
currently supports only POLYTCOUNT=MAXSTEPS ("hard" polytomies), and will 
ignore the POLYTCOUNT specification.
Future NEXUS-conforming programs may define additional options; the ERRORSTOP 
setting (see SET command) determines how PAUP will react to unrecognized option 
keywords.

TYPESET
Use the TYPESET command to define a "type set."  The syntax is:
TYPESET [*] type-set-name = character-type : character-list
     <, character-type> : character-list >...;
The character-type must be one of the standard character types (ORD, UNORD, DOLLO, 
DOLLO.UP, DOLLO.DN, IRREV, IRREV.UP, or IRREV.DN) or the name of a user-
defined character type.  Any number of character-type:character-list pairs, separated by 
commas, may be specified. 

USERTYPE
Use the USERTYPE command to define a new character-type.  The syntax is:

     USERTYPE character-type-name [ { STEPMATRIX | CSTREE } 
               = character-type-description ; ]

Character-type-description must follow the rules for character-state tree or stepmatrix 
description outlined in the section "Defining Your Own Character Types" (Chapter 2).

WTSET
Use the WTSET command to define a "weight set."  The syntax is:

     WTSET [*] weight-set-name = character-weight : character-list
           [ , character-weight : character-list ] ... ;
or
     WTSET [*] weight-set-name VECTOR = wt1 wt2 wt3 ... wtNCHAR;

Character-weight must be a nonnegative integer value.  In the first form, any number of 
character-weight:character-list pairs, separated by commas, may be specified.  In the 
second form, a single weight is provided for every character.

An example ASSUMPTIONS block follows, with examples of each of the available 
statements:

    BEGIN ASSUMPTIONS;
        OPTIONS DEFTYPE=ORD POLYMCOUNT=ADDSTEPS;
        USERTYPE myOrd = 4      0  1  2  3
                    -  1  2  3
                    1  -  1  2
                    2  1  -  1
                    3  2  1  - ;
        USERTYPE myTree CSTREE = ((0,1)a,(2,3)b)c;
        TYPESET * mixed = IRREV: 1 3 10, UNORD 5-7;
        CHARSET odd = 1-.\2;
        CHARSET even = 2-.\2;
        WTSET *one = 2: 1-3 6 11-15, 3: 7 8;
        WTSET two = 2:4 9, 3:1-3 5;
        EXSET nolarval = 1-9;
        ANCSTATES allzero = 0:ALL;
        ANCSTATES allone = 1:ALL;
        ANCSTATES mixed = 0: 1 3 5-8 11, 1: 2 4 9-15;
     ENDBLOCK;

Any number of USERTYPE, TYPESET, WTSET, EXSET, and ANCSTATES statements 
may be provided.  Each one has an associated tag; you can choose the desired setting via a 
SET command or, in versions of PAUP that provide menus, from a "Choose ..." menu 
command.
The TREES block is used to input user-defined trees to PAUP.  A single tree or utree 
command is used for each tree; any number of tree or utree commands may be included in 
the block.
The syntax for the TREES block follows:

   BEGIN TREES [block-name] ;
      [ TRANSLATE token taxon-name [ , token taxon-name ] ... ; ]
      [ TREE [*] name = tree-specification; ]
      [ UTREE [*] name = tree-specification; ]
   ENDBLOCK;

The TREE and UTREE commands are used to input rooted and unrooted trees, 
respectively.  To input multiple trees, you may use as many tree or utree commands as you 
need.  However, you may not mix tree and utree commands—all of the input trees must 
either be rooted or unrooted.

Tree descriptions require that taxa be referred to by the name assigned to them in the DATA 
block.  However, the TRANSLATE command can be used to define a translation table that 
maps arbitrary tokens in the tree specification to valid taxon names.  If a TRANSLATE  
command is not present, a default translation table maps the integers 1 through NTAX to 
the corresponding taxon names in the data matrix, so that integer values rather than taxon 
names may be used in the tree specifications.  However, it is usually best to avoid relying 
on a default translation table.  For example, if you rearrange the order of the taxa in the data 
matrix, this reordering will not affect the validity of the tree descriptions so long as you 
either retain the original translation table or use taxon names rather than numbers in the tree 
descriptions.  There are two advantages to using a translation table rather than using the 
taxon names directly in tree descriptions.  First, tree descriptions are generally much more 
compact when integers rather than taxon labels are used, especially if a large number of 
trees are being described.  Second, if you decide to rename a taxon, only one element of the 
translation table need be changed.  Without a translation table, the old taxon name would 
have to be changed to the new one in every tree description.

TREES-block processing is much faster if you use the consecutive integers 1, 2, ..., 
NTAX for the arbitrary tokens in the translation table.  Unless you have a good reason for 
not doing so, you should follow this convention, especially if a large number of trees are 
being defined.

A sample TREES block for four taxa named 'one', 'two', 'three', and 'four' is shown 
below:

   begin trees;
   translate
      1 one,
      2 two,
      3 three,
      4 four;
      tree a = ((one,two),three,four);
      tree b = ((one,two),(three,four));
      tree c = ((one,two));
      tree d = (1,(2,(3,4))); [uses translation table]
   endblock;

If one or more taxa are omitted from a tree specification, they are joined to the root node of 
the subtree described by that specification.  It is recommended that taxa be excluded from 
tree description only for constraints input.
One or more PAUP blocks may be included in the data file in addition to the standard 
blocks.  Any valid PAUP command may be placed in these blocks.  In some cases, it may 
be easier to include commands in the file than to enter them from the command line or make 
the corresponding requests via the menu system.

Example:

    BEGIN PAUP;
        exclude 1 5 10-12;
        wts 2:1-10, 3:11-20;
        set maxtrees=200;
        hsearch/keep=120;
        describe all/chglist apolist;
     ENDBLOCK;
PAUP has a standard Macintosh interface including pulldown menus, dialog boxes, and 
scrollable lists.  The following screens provide additional information the Macintosh 
interface to PAUP.
The PAUP editor has most of the features expected of a Macintosh text editor, including 
horizontal and vertical scroll bars, cut, copy, paste, clear, and undo facilities, selection of a 
"word" by double-clicking, etc.  You may also select an entire line by triple-clicking.

You may set the font, size, and tab width by choosing "Editor..." from the Options menu.  
Although it is not required, you are strongly urged to use a monospaced font like Monaco 
or Courier so that columns of the data matrix will line up cleanly.  (The default font, 
PAUPMonaco, is a modification of Monaco that overcomes some of the shortcomings of 
Monaco.  Specifically, it distinguishes between zero and the upper-case "oh", between the 
lower-case "el" and the upper-case "I", and increases the size of several punctuation 
characters for improved readability.
All of PAUP's capabilities may be invoked using either the menus or the command line.  
To use the command line, choose "Command Line" from the Windows menu and type in 
the desired command.  For a complete list of available commands, see "PAUP commands".
Many dialogs contain scrollable lists from which you may select more than one item (e.g., 
lists containing tree numbers, character numbers/labels and taxon labels).  To select 
multiple items, you must either "shift-click" or "command-click".

In lists that allow multiple selections, if neither the shift key nor the command key is held 
down, a click causes all current selections to be deselected and the item receiving the click 
to be selected.  If the shift key is held down, then as long as the mouse button is held 
down, the current selection is either expanded or contracted.  If the command key is held 
down, then the selection status of a cell receiving a click is toggled.  (I.e., if it was 
originally selected, it becomes deselected, and vice versa.
The "Defaults..." button present in most dialog boxes allows you to redefine PAUP's 
current and/or default option settings.  Three choices are available.  You can restore the 
current option settings to the values that were in effect at the time at the program was started 
or to the "factory settings" (the default values that are set when PAUP is shipped).  
Alternatively, you can make the CURRENT settings become the default settings for 
subsequent runs of the program. 
In addition to the standard Apple, File, and Edit menus, PAUP provides the following 
menus: Options, Data, Search, and Trees.  The available choices are described in 
subsequent screens.
Along with your usual set of desk accessories, the Apple menu contains choices for the 
"About PAUP" window (which displays, among other things, the current version number) 
and for the help system (see previous screen).
The File menu is used to create, open and save input/output files, to control certain printing 
options and operations, and to exit the program.  The options available on the File menu are 
described below.
Use "New" to create a new PAUP input file.  A new, untitled window will be created.  See 
"The PAUP Editor" for more information on how to use the editor.
Use "Open" to execute or edit an existing PAUP input file.  On the standard file dialog, 
choose either "Execute" or "Edit", then select the name of the file you want to open and 
click the Open button (or just double-click on the file name).  Note that by default, PAUP 
shows only those files created by PAUP or MacClade.  If your file was created by some 
other program, click "All TEXT files" to display the full set of files that can be opened by 
PAUP.
Use "Close" to close the active window (generally an editor window, but it may be the 
command-line or memory-status windows).  This is equivalent to clicking the mouse in the 
close-box of the window.  (Some windows, such as the main display and search-status 
windows, can not be closed.)
Use "Save" to save the file being edited in the active window to disk.  The file will be 
saved in exactly the same place it was when you opened it.  (If you want to save a copy of 
the file under a different name or in a different place, use "Save As" rather than "Save.")  
Note that if the file has not previously been saved (i.e., if it was created via "New"), you 
will be requested to name it using the standard dialog.
Use "Save As" to save the file being edited in the active window to disk.  Ordinarily, you 
will use "Save As" only when you want to save the file being edited with a different name, 
in a different folder, or on a different disk.  Name the file using the standard file dialog that 
is provided.

"Save As" will also change the type of a file to a PAUP document.  After doing so, double-
clicking on that document from within the Finder will start PAUP with the chosen file as 
the active file.
Use "Revert" if you want to abandon changes to a document (e.g., PAUP data file) being 
edited without leaving the editor.  The most recently saved version of the file will be 
restored to the editor window.
This brings up the standard system "Page Setup" dialog, which lets you define printing 
features such as the size and orientation of the paper on which a document is printed.  See 
your Macintosh documentation for further information on available options.
Choose "Print File" to print the document being edited (generally a PAUP input or output 
file) to the currently active printer.  (You can use the Chooser desk accessory to change 
printers.)  Note that "Print File" may only be used while in editor mode; it is disabled 
otherwise. If no file editor window is open, this choice will change to "Print Display 
Buffer."

The standard system printing dialog will appear, allowing you to specify 
things such as the number of copies, page range, etc.
This command causes all output currently stored in the "display buffer" to be copied to the 
printer.  Note that the number of lines that may be stored in the display buffer is limited; 
some of the output may have already been lost (scrolled off the top).
If you choose "Echo to Printer", all subsequent output to PAUP's main display window is 
also sent to the currently active printer.  Each time you choose "Echo to Printer", it will 
toggle the current printing status.  (Printing is on if the item is checked in the menu, and off 
otherwise.)

You may also save output to a disk file and then print it later using PAUP or a text-
editor/word-processor of your choice.  See "Log Output to Disk" for further information.
This command will print any text that you have selected in an editor window or the display 
buffer. 
The "Log Output to Disk" command allows you to control the saving of PAUP output to 
disk files.  To being saving output, use the standard file dialog to name the output file, then 
press "Start saving".  All subsequent output generated by the program will be saved in this 
file.  If you want to stop saving the output to disk, choose "Output to Disk" and press the 
"Stop saving" button.

The "Output to screen" checkbox in the dialog allows you to specify whether output is also 
written to PAUP's main display window.  If you want to send output to the file only, 
without having it scroll by on the screen, uncheck this box. The "Copy current contents of 
display buffer to file" checkbox will save the display buffer as well.  

If you attempt to output to an already existing file, you will be asked whether you want to 
append to the file or to replace (overwrite) it.
Use this command to request processing of the indicated file.  If you are in editor mode, the 
file being edited will be executed.  Otherwise, "Execute" will operate on the most recently 
closed file.  For example, you can open a file for editing, make any desired changes, save 
and close it, and then execute it.
Choose Export File to export a data matrix and/or tree descriptions in one of three available 
formats: (1) PHYLIP (J. Felsenstein's Phylogeny Inference package), (2) Hennig 86 (J. S. 
Farris's IBM-PC program for phylogenetic analysis), and (3) tab-delimited text (a general 
format readable by Excel and other programs).

A data matrix must have been successfully input to PAUP (via a DATA block) for this 
command to be available.  If there are trees in memory, you may export these as well; 
however tree export is supported only for PHYLIP and Hennig 86 formats.  To export the 
data and/or trees, name the exported file in the field provided by the standard file dialog 
box, choose the desired format (pop-up menu) and export options (check boxes), and click 
on Export.

PHYLIP's "discrete (0,1)" programs are restricted to binary characters. Neither Hennig86 
nor PHYLIP accept multistate taxa.  If the characters are binary or ordered multistate, they 
can be equivalently recoded (but only under the interpretation of uncertainty rather than 
polymorphism) using additive binary coding with missing values used to indicate the points 
of uncertainty.
The Import File command allows you to import a file in one of four primary formats: 
PHYLIP, Hennig 86, tab-delimited text, or simple text.  A pop-up menu will appear for 
you to select the file format to be imported.  You can select from text, PHYLIP, Hennig86, 
GCG MSF, or NBRF-PIR by using the pull-down menu that appears when Import File... 
is selected. Examples of GCG-MSF and NBRF-PIR file formats are included in the sample 
data files included with the PAUP program.

The simple-text and tab-delimited-text formats have a very restrictive format.  You must 
place all of the data for each taxon on a single line.  For "simple" text, first provide the 
taxon name followed by one or more spaces or tabs, then the state of the first character, the 
second character, and so on until the last character.  You may separate the character-states 
with spaces or tabs, but you are not required to do so.  If the taxon name contains any 
blanks, represent these as underscores.  If the taxon name contains special punctuation 
characters, you must enclose it within single quotes.  (If you use quotes, you should use an 
actual space character rather than an underscore character to represent blanks.)  The tab-
delimited text is essentially identical, except that each pair of character states must be 
separated by a tab.  A tab must also separate the taxon label from the first character state.
Use the "Quit" command when you want to exit from PAUP and return to the Finder.
The Edit menu contains the standard Undo, Cut, Copy, Paste, and Clear items, which are 
available while in PAUP's editor.  You may also clear PAUP's display buffer from the Edit 
menu.
Use this command to "undo" your last text-editing action.  Generally, the word "Undo" 
will be followed by the undo-able action (e.g., "Undo Typing", "Undo Copy", etc.
"Cut" removes the selected text and replaces it on the Clipboard.  (Any previous contents of 
the Clipboard are replaced.)  The "Cut" command is disabled if no text is selected.
"Copy" puts a copy of the selected text on the Clipboard.  (Any previous contents of the 
Clipboard are replaced.)  Unlike "Cut", the selected text is not removed.
"Paste" inserts a copy of the contents of the Clipboard at the insertion point.  (If text is 
selected at the time "Paste" was requested, it will be replaced.)
In editor mode, "Clear" removes the selected text without altering the contents of the 
Clipboard (unlike "Cut", which deletes the selected text but places it on the clipboard).
This will select all text in the open window.  You can then perform the above actions on all 
selected text.
Use this command to clear all output in PAUP's display buffer from memory, allowing 
you to start with a "fresh" display window.
This command causes the current contents of the display buffer to be placed into a new, 
untitled, editor window for editing or printing.  For example, you might want to save only 
a portion of the output currently stored in the display buffer for subsequent retrieval.  You 
can do this by choosing the Edit Display Buffer command, deleting the portions of the 
output you do not want to save, and then requesting the Save command (File menu) to save 
the remaining output.

The current "semigraphics" mode is respected (see the Semigraphics... command of the 
Options menu).  If you have disabled the translation of semigraphics characters to standard 
ASCII characters, you will not be able to print these characters in any font other than the 
special Monaco font included in PAUP.
This allows you to choose the tab stops and font that PAUP will use while editing.  
This option allows you to find a specified text string within the document., and to specify 
other text with which to replace it (the actual replacing is done using the Replace command, 
below).  
This option repeats a previous Find command. 
This replaces highlighted text with the text specified in the Find command. Use Find Again 
and Replace to cycle through all occurrences of the text specified in the Find command.
This option finds and replaces all instances of the text specified in the Find command. 
The Windows menu allows you to open available windows or bring them to the front if 
they are already open.  
Choose Main Display to bring PAUP's main display window to the front.  (The same 
effect may be achieved by simply clicking on the main display window, but it may be 
entirely covered by other windows.)  The width of the main display is the same each time it 
is called up.  You may shrink it by holding down the "option" key while clicking and 
dragging on the lower right-hand corner.  It cannot be expanded beyond the standard size. 
Choose "Command Line" to open the command-line dialog, or to bring it to the front if it is 
already open.  The command line provides an alternative way to control PAUP's actions.  
The available commands are identical to those found in "generic" mainframe/minicomputer 
versions of PAUP, and are fully documented in the User's Manual.  If the command line is 
active, type in the desired command and press "OK" or hit return.  Press "Cancel" to clear 
the command line.

Some users may find the command-line to be a more efficient interface, particularly for 
certain operations that require a lot of "pointing and clicking" within dialog boxes.
This command adds a line at the top of the main display window that provides constant 
monitoring of memory availability.  (If the memory-status window has already been 
opened, Show Memory Status brings the window to the front.)  Two pieces of information 
are available: (1) the total amount of memory available (i.e., not already allocated by the 
System, by PAUP, or by other programs and desk accessories), and (2) the size of the 
largest free memory block.  Knowing how much memory is available can be useful if you 
are working near the limits of the memory capacity of your machine.

If you no longer want to see the memory status, bring it to the front and choose Close from 
the File menu (or click in the window's close box).
Choosing "Search Status" brings the status window for a heuristic, branch-and-bound, or 
exhaustive search to the front.  It is useful when the status window has been completely 
obscured by other windows.  "Search Status" is only available when a search is actively 
being performed; it will be disabled at other times.
Choosing PAUP Help will bring up this help system.  You can view the contents by topic 
only, or read the help entry for a particular topic.  When you are done using help, choose 
the Exit button to return to PAUP.  The help file must be in the same folder as PAUP when 
PAUP is started, otherwise it will not be found when Help is selected. 
This option zooms the current window to full size.  Reselecting Zoom will restore it to its 
original size.
This option will restore all windows to their default location settings.  If the "option" key is 
held down when this is selected, only the editor windows are affected.  Editor windows 
will be "stacked" so that all title bars are visible. 
This option will close all open editor windows. 
The Windows menu will ordinarily also contain the names of additional files that are 
available for editing.  Choosing one of these filenames will cause the window for that file 
to be brought to the front, reading the file from disk if necessary.

You can also select a file for editing by clicking anywhere in an already open window.  
However, the window may be hidden from view by other windows, in which case the 
Windows menu provides a means of bringing the window to the front. 
The Options menu is used to control a number of option settings that affect PAUP in 
various ways.  See the following screens for further details.
This command allows you to specify how PAUP treats "multistate taxa" when computing 
tree lengths.  Multistate taxa are those for which more than one character state was assigned 
to taxa in the data matrix for some characters.

When multiple states are interpreted as "uncertainty," PAUP will choose a state from the set 
of available states that allows minimization of the tree length.

When multiple states are treated as polymorphism, PAUP assumes that the "terminal taxon" 
is actually a heterogeneous group.  In this case, all but one of the states in the polymorphic 
terminal taxon must be derived from a monomorphic ancestral taxon in the most 
parsimonious way possible.  
This command allows you to specify the method used to resolve ambiguity when 
optimizing ordered (Wagner) and unordered (Fitch) characters.  Three choices are available: 
(1) delayed transformation, which can be thought of as preferring  parallelisms over 
reversals; (2) accelerated transformation, which maximizes prefers reversals to 
parallelisms, and (3) minimum F-value, which moves length from interior branches toward 
peripheral branches wherever possible.
Use "Set Maxtrees" to specify the maximum number of trees that will be held in memory 
by PAUP.  The trees are stored in a "tree buffer" which can be resized on demand if it 
becomes full.

Setting the Maxtrees parameter to a large value will reduce the likelihood that the tree buffer 
will become full during a search, at the expense of a larger chunk of memory being tied up 
and therefore unavailable for other purposes.

Ordinarily, if the number of trees found during a search reaches the value of Maxtrees, you 
will be given a chance to increase Maxtrees before proceeding.  However, if you uncheck 
the "Prompt for a new value..." box, the program will not stop when Maxtrees is reached.
Use this command to change the way PAUP formats character-state matrices for output.

You may specify whether to use character numbers or alphanumeric names (if available) for 
the column headings.  Left-to-right vs. top-to-bottom mode may be chosen for both 
alphanumeric names and character numbers.

You can also control the number of columns used for each character.  A column width of 
one character works well for nucleotide sequence data, but for other kinds of data some 
extra spacing may be more pleasing.

Finally, you may choose whether or not to include information on character status (i.e., 
deleted characters, uninformative, and/or constant characters are flagged). 

A good way to learn the difference between the various formatting options is just to try 
displaying a data matrix with different settings in effect.
This command controls status-window display and event checking while PAUP is 
searching for trees. 

Ordinarily, PAUP continues processing (e.g., tree searches) when it is switched to the 
background, allowing other activities (e.g., word processing) in the foreground.  For large 
data sets, however, the responsiveness of the foreground application may be impacted.  If 
you disable background processing, PAUP will simply "sleep" when it is switched to the 
background and will resume processing when it is returned to the foreground.  For 
example, a run could conceivably continue over a period of several days by letting PAUP 
sleep during the day when you were using your machine for "more important" tasks but 
moving PAUP to the foreground when you left for the day.

If event checking is disabled, PAUP will ignore all mouse-clicks and key presses.  Because 
event-checking steals processor time from PAUP's computations, disabling it will provide 
a speed improvement.  However, you give up the ability to abort a search (other than by 
restarting the computer)  or to activate a different program under MultiFinder.
The "Rooting..." command allows you to specify whether unrooted trees will be rooted 
using the outgroup or the Lundberg methods.  Outgroup rooting chooses the root so that 
the ingroup is monophyletic (if possible).  If the outgroup is defined in a way that makes it 
impossible to root the tree such that the ingroup is monophyletic, the "ingroup" portion of 
the tree will include one or more outgroup taxa.  The outgroup may be defined using the 
"Define Outgroup" command in the Data menu or by an "outgroup" command from the 
command line.  If no outgroup has been chosen and outgroup rooting is in effect, the first 
non-deleted taxon in the data matrix will be chosen as the outgroup.

Lundberg rooting operates by locating the point on an undirected tree at which an 
outgroup/hypothetical ancestor would attach most parsimoniously.  The outgroup/ancestor 
is defined using the ANCSTATES statement in an ASSUMPTIONS block and must be 
chosen using the 'Choose Assumption Sets" command in the Data menu before it is 
available for Lundberg rooting.

Lundberg rooting is available only when all characters are of either ordered (Wagner) or 
unordered (Fitch) type.  Note that the 'standard' ancestor contains all missing values for 
these character types.  Consequently, it may not be used for Lundberg rooting since its 
attachment to any branch of the tree would add zero length, and all rootings would be 
equally parsimonious.  
See the Users Manual for complete  details on how these rooting methods work.
The "order" of the taxa in a tree drawn by PAUP has no physical significance; three options 
are available to control the ordering.  By default ("standard"), the tree is drawn so that the 
order of the taxa on the tree matches the input order in the data matrix as closely as 
specified.  "Ladderize left" means that the tree is made as asymmetrical as possible by 
sorting the descendants of each interior node so that the leftmost (or topmost) descendant 
has the greatest number of immediate descendants.  "Ladderize right" is equivalent except 
that the sorting is performed in the opposite direction. "Alphabetical" arranges the taxa in 
alphabetical order as nearly as possible. 

The standard and alphabetical orders are best for visual comparison of different trees for the 
same set of taxa, whereas the ladderized orders sometimes provide a more pleasing 
appearance (i.e., they reduce the "monkey-puzzle" like appearance that sometimes 
characterizes the standard and alphabetical orders).
This allows you to choose which character states to allow in internal nodes. 

When a stepmatrix contains three or more character states, it is possible that full 
minimization of the tree length may require assignments of character states that were not 
observed in any of the terminal taxa to internal nodes.  This will often be the case when 
only a few character states were observed for a stepmatrix character, but the stepmatrix is 
defined for a large number of character states. When this happens, execution in PAUP is 
slowed significantly if all character-states are allowed as candidates for assignment to 
internal nodes. 

PAUP provides three options for dealing with this problem. First, you may choose to 
restrict the states for internal nodes only to those observed in terminal taxa. Second, you 
may choose to allow any state contained in the stepmatrix definition to be assigned to 
internal nodes regardless of whether it was observed in a terminal taxon.   

The third option provides a compromise between these two extremes.  It uses the "3+1" 
rule. Applying the rule independently to each character, all triplets of observed character 
states are examined, in turn.  For each triplet, each member of the triplet is assigned  to one 
of the terminal nodes of a 3-branch tree. Then, every character-state contained in the 
stepmatrix definition is assigned, in turn, to the single internal node and the length required 
for the character, given these state assignments, is computed.  If assignment of an 
unobserved character state to the internal node yields a length less than or equal to that 
obtained from one of the three members of the triplet, this unobserved state is added to the 
set of candidate states.
This option effectively removes invariant or uninformative characters from the analysis, 
although they remain in the data file.  
PAUP uses special characters in its internal font to draw trees and other items.  These 
characters are neither in the standard 128 ASCII characters nor in the set of special 
characters normally included with Macintosh fonts.  Thus, although the trees look nice 
when drawn in the display buffer, they will not look right when printed on most printers.  
Ordinarily, PAUP translates these "semigraphics" characters to standard ASCII substitutes 
when sending output to a printer, file, or document window.  Choosing the "Leave Alone" 
checkbox will not translate the characters, and printed characters will look as they do in the 
display buffer. 
The "Editor" command in the Options menu allows you to change options that affect 
PAUP's editor.  You may change the type font, size, and number of spaces that are 
equivalent to one tab.  If you change the font, it is strongly recommended that you use a 
"monospaced" font like Monaco or Courier so that columns will line up evenly.

In addition, you may enable or disable the "autoindent" facility.  If autoindenting is on, 
when you hit return at the end of a line, the cursor is automatically indented to the same 
column position as the starting point of the previous line.
Use "Warnings & Errors" to specify what action PAUP will take when it encounters 
unrecognized commands and keywords in a file, to specify sound options, and to enable or 
suppress the warnings PAUP issues before resetting the active data file.  These options are 
largely self-explanatory; with the exception of the last.

The 'active datafile' is the file containing the most recently processed DATA block.  If 
another 'data' block is encountered when executing a file, the previous data matrix (and any 
trees that may have been generated using this data matrix), will be cleared from memory.  
By default, PAUP warns before resetting the active data file on the chance that the 
'Execute' command was issued inadvertently.  If you wish to suppress this warning, 
uncheck the "Warn before resetting active datafile" item.
This option allows  you to choose different options for NEXUS files.

In this dialog box, you can choose to have "end" be a valid block terminator in the file (as 
well as "endblock").  You can also choose to allow or disallow all digit taxon and character 
labels. 
Use this command to change the default settings that go into effect when PAUP starts.  
You can set initial value of the Maxtrees parameter (see "Set Maxtrees").  You may also 
specify the amount of memory allocated for the display buffer in the range 32K to 128K.  
(The more memory that is allocated for the buffer, the greater the number of lines can be 
retained for subsequent recall, but the less memory that will be available for other 
purposes.)  

You may also set the default settings for most of the options in the program to either the 
values that are currently in effect or to the values that are in effect at the time PAUP is 
originally shipped ("Factory settings").  If the Save button is pressed, a file called "PAUP 
Preferences" will be created or modified in the System Folder of the disk from which the 
computer was booted.  (If a previous version of this file already exists, it will be replaced.)  
If you instead press the Save As... button, a standard file dialog box will appear that allows 
you to create a file with any name and folder location you choose.  This new file can then 
be used to start PAUP (by double-clicking from the Finder) with the chosen default 
settings.  In this way, you can have a variety of default configurations.  Click on the boxes 
for Show command line and/or Show memory status if you wish these to be active when 
PAUP starts. 
Finally, you can have PAUP remember the location of windows, so that the next session 
will start up with the windows in the same place. 
Use this command to set the current option settings to those that were in effect at the time 
the program was started ("current startup defaults") or to the values in effect at the time 
PAUP is originally shipped ("factory settings").
The Data menu contains commands for setting character types and weights, excluding taxa 
and characters from the analysis, and displaying information concerning the current data 
set.  See the following screens for further information.
This command provides a facility for excluding characters from consideration when 
computing tree lengths.  Although the excluded characters will not be allowed to influence 
the selection of optimal trees, they will still be optimized to these trees.  For example, you 
can construct trees using only a subset of the characters, but still see how the remaining 
characters would be "mapped" onto the resulting tree(s).  

A dialog box with two scrollable lists will appear.  The left list contains the included 
characters, and the right list contains the characters that are to be excluded.  Select the 
characters you want to include or exclude, and press the appropriate arrow button to move 
characters from one list to the other.
Use this command to change the type of one or more characters.  Available character types 
are ordered (Wagner), unordered (Fitch), Dollo, irreversible (Camin-Sokal), and user-
defined.  See "Character Types" for a brief description of these character types.

When you choose "Set Character Types", a dialog containing a scrollable list of character 
numbers (and names, if you have provided them) will appear.  Select the character(s) 
whose type(s) you want to change and click on one of the character-type buttons at the 
bottom of the dialog.  (See "Selecting Items in Lists" for tips on making multiple 
selections.)  The list will be updated to reflect the new character status.  You may then 
proceed to select other characters and set their types in the same manner.

If the "Dollo" or "Irreversible" buttons are pressed, a menu will pop-down allowing you to 
choose an option for specifying character polarity.  (See "Character Types" for the meaning 
of these options.)  Similarly, if the "User-Defined" button is pressed, a menu will pop-
down that shows the user-defined types that were specified in the ASSUMPTIONS block.  
Choose the desired type from this menu.
Use this command to change the weight assigned to each character.  By default, all 
characters are weighted equally (with a weight of unity).  To change the weights, select all 
characters to be assigned a given weight, enter the desired weight in the box provided, and 
click on "Apply."  When you are finished assigning weights, click on "Done".

In addition to providing explicit weights, you may choose to scale character weights so that 
each character receives the same total weight regardless of the number of states observed.  
(For instance, if a data matrix contains characters with 2, 3, and 4 states, the  4-state 
characters could be weighted 2, the 3-state characters weighted 3, and the binary characters 
weighted 6.  In this way, the total range of all characters is 6.  (This type of weighting is 
especially appropriate when the number of character states assigned to a character is 
essentially arbitrary, as when continuous measurements are recoded into discrete 
characters.)  

Because Versions 3.0 and later of PAUP uses integer weights and tree lengths, you can no 
longer use decimal weights such as 0.33, 0.5, and 1.0 for the above example.  Instead, 
specify the "base weight.  This can either be a "common denominator" or a large value like 
100 or 1000.  For example, using a base weight of 100 provides results equivalent to using 
decimal weights recorded to 2 decimals.
This provides the option of a posteriori weighting of characters.  You must first calculate 
some trees using equal weights.  Then, reweight the characters depending on consistency 
index, retention index, or  rescaled consistency index.  If there is more than one tree, you 
can choose to weight by the best, worst, or average fit of the character over all trees. You 
can also specify whether weights are truncated or rounded.  Hennig 86 truncates weights, 
and if you wanted to replicate a Hennig86 search, you would have the weights truncated.  
This means that a character with a CI of .87 with a base weight of 10 would receive a 
weight of 8 instead of 9, the value obtained by rounding. 

You also have the option of specifying the base weight for reweighting.  After assigning 
the new weights, a new search is run.  The cycle continues until either the weights do not 
change over two successive runs, or the same set of trees is obtained in two successive 
runs.  
Use this command to temporarily delete taxa from the analysis or to restore previously 
deleted taxa.  A dialog with two scrollable lists will appear.  The list on the left contains 
nondeleted taxa and the list on the right contains taxa that have previously been deleted.  
Select taxa in either list and click on the appropriate button to change the deletion status of 
the taxa.
Use this command to define the outgroup.  A dialog with two scrollable lists will appear.  
The list on the left contains taxa currently assigned to the ingroup, and the list on the right 
contains outgroup taxa.  Select taxa in either list and click on the appropriate button to move 
taxa between the ingroup and the outgroup.
This command produces a listing of the current status of all characters.  Output includes the 
character type, states observed, exclusion status, and information on whether the character 
is "informative."
This option produces output listing all deleted taxa and all taxa currently included in the 
outgroup. 
This command generates a listing of all user-defined character types (stepmatrices and 
character-state trees).  Character-state trees are shown in a graphical format so that you can 
see whether the tree you described is in fact what you intended.  Input of stepmatrices is 
less problematical but it is nonetheless useful to include a record of the costs assigned by 
the stepmatrix in the output. 
This command produces a listing of the data matrix.  The "Character-Matrix Format" 
command available in the Options menu can be used to control the format of this listing.
Use this command to request calculation and output of a matrix of pairwise distances 
between taxa.  The formulas used in calculating these distances are given in the User's 
Manual.  If missing data are present, the upper triangle shows mean distances computed 
over only those characters for which both members of a pair have nonmissing values.
This command produces a listing of the currently defined ancestral states, in a format 
similar to that used for showing the data matrix.
Use this command to invoke previously defined "assumption sets."  Four kinds of 
assumption sets are available.  TYPESETs and WTSETS specify character types and 
weights, respectively, for sets of characters.  (See the "5-taxon test" data set for examples.)   
EXSETS define sets of characters that are to be excluded from consideration during 
searches.  ANCSTATES specify ancestral states for each character.

Assumption sets are particularly useful when complex combinations of assumptions are 
being used.  By declaring assumption sets, complicated sequences used to assign character 
types and weights, etc., can be avoided. 
Items on the Search menu allow you to search for trees using heuristic or exact algorithms, 
to perform "bootstrap" analyses to estimate the reproducibility of groupings, and to 
perform Lake's method based on linear invariants for DNA/RNA sequence data.  Also, 
commands dealing with input and selection of constraints are included on the Search menu.

See the following screens for details.
Ordinarily, topological constraints are defined via CONSTRAINTS statements in a PAUP 
block.  The "Load Constraints" command provides an alternative means of defining 
constraints that may be simpler in some cases.

When you choose "Load Constraints", a standard file dialog will appear.  Select a file that 
is known to contain a NEXUS TREES block.  The trees in this block will be read from the 
file and are then available for use as constraints specifications.  All other information in the 
file is ignored.

If constraints have already been defined prior to issuing the Load Constraints command, 
you can choose Replace existing constraints to replace the existing constraint tree with the 
new ones loaded from the file or Add to existing constraints to add the new constraint trees 
to the ones already present.  If you are loading a tree as a "backbone" constraint, check the 
'Load as "backbone" constraints' box.

The Load Constraints command is particularly useful if you are using PAUP and MacClade 
in conjunction with each other.  It is often easier to use MacClade to graphically edit the tree 
descriptions that you wish to use as constraints than it is to write out the tree description in 
the parenthetical notation used by PAUP.  MacClade can save the trees to a file from which 
constraints can be loaded by PAUP.
This command causes a tree representing the currently chosen constraint definition to be 
output.  You may also choose to see other constraint definitions as well.
Use "Heuristics" to request a search using a heuristic (approximate) algorithm. Use 
Heuristics to request a search using a heuristic (approximate) algorithm.  A heuristic search 
ordinarily includes two components: (1) stepwise addition of taxa to a developing tree until 
all have been connected, and (2) rearrangement of these trees via "branch-swapping" 
techniques.

There are too many heuristic search options to include them all in a single dialog box.  
Consequently, the controls for these options are divided into four panels.  To select a 
different panel of options, simply click on one of the radio buttons at the left of the dialog 
box.

The first panel of options can be used to specify several general options: Typically, you 
will keep only the minimum-length trees but you may also be interested in near-minimal 
trees as well.  You can save all trees less than or equal to a length that you specify by 
clicking the appropriate radio button and entering the desired length into the adjacent field.  
You can also choose to enforce topological constraints during the search, and keep trees 
that do/do not satisfy the constraint (either backbone or monophyly).  When "Constraint 
trees" is selected, a pull-down menu will appear if there is more than one currently defined 
constraint tree.

The "Include ancestral taxon" checkbox allows you to specify that the currently defined 
ancestral states (ANCSTATES) are to be treated as corresponding to a hypothetical 
ancestral taxon used to root the trees during the search.  In most cases, you will leave this 
box unchecked (in which case trees are stored internally as unrooted trees and rooted only 
for output purposes only).  Use it only if you have specified an ancestor different from the 
standard (all-missing) ancestor.  If you do not, all rootings will be equally parsimonious 
and will be saved as distinct trees.

The second panel allows you to choose how the starting trees will be obtained: by stepwise 
addition, or by using some or all of the trees already in memory.   You can also choose to 
swap on all the trees in memory (including nonminimal trees) or  on minimal trees only by 
selecting the appropriate checkbox in the "Swap on" option. 

The third panel has options for stepwise addition.  the addition sequence can be simple, 
closest, asis, or random.  You can also select how many trees are held at each step.  For 
random addition, you may change the number of repetitions or the seed tree.  You can also 
select a running status report of the random search.   Using the random addition sequence 
option is the best way to find islands of trees that may not be discovered by other addition 
sequence options.

The final panel has options for branch swapping.  You can choose the swapping option 
you want: tree bisection-reconnection; subtree pruning-regrafting; or nearest-neighbor 
interchange.   If you wish, you can also select no swapping, performing the stepwise 
addition phase only. PAUP will save all minimal trees if MULPARS is selected.  Selecting 
"Save no more than ___ trees ≥ length ____" is handy when searches get bogged down 
finding huge numbers of trees that are far from optimal, especially when used in 
conjunction with random addition sequence  You can also choose to have PAUP abort the 
current replicate if the Save limit is hit during random addition.  Steepest descent will not 
abandon a round of swapping until all input trees from the previous round have been 
examined by the swapping algorithm.  
Use this command to request a search using the branch-and-bound method.  This algorithm 
is guaranteed to find all minimum-length trees.

If you do not provide an initial upper bound, one will be calculated via stepwise addition.  
However, the better the upper bound, the faster the branch-and-bound search will proceed, 
so for large data sets, it will generally be worth your while to perform more extensive 
heuristic searches in search of a better bound prior to starting the branch-and-bound search.
The addition sequence specifies the way in which taxa are selected for next addition to the 
tree at the current node of the search tree.  FURTHEST is usually the fastest, although it is 
not permitted unless all characters are of type ORD or UNORD.

If you only want to know the length of the shortest tree(s) and do not care to obtain all trees 
of this length, uncheck the "Save all minimal trees" (MULPARS) option.  The single tree 
found is guaranteed to be of minimum length and the search often  runs much faster.

If you check "Tree length frequency distribution only", PAUP will not save any trees but 
instead compute a frequency distribution of the number of trees of each length less than or 
equal to the length specified for "Keep all trees ≤ length ___"  This provides a way to 
obtain the number of trees that are one step from optimal, two steps from optimal, etc., for 
data sets that are too large to allow a full computation of the tree-length frequency 
distribution via exhaustive search.
The branch-and-bound run times are very data-dependent.  It usually runs quickly for 12 or 
fewer taxa.  For between 13 and 18 taxa, the run times vary considerably depending on the 
messiness of the data and other factors to complicated to go into here.  It has been 
successfully run for 20 or more taxa, but for data sets this large, extremely long run times 
are possible.  Don't even try it for data sets much beyond 20 taxa.
The "Exhaustive Search" command provides an alternative to the branch-and-bound for an 
exact search, guaranteeing to find all minimum-length trees.  If all you are interested in is 
the most parsimonious trees, you should use the branch-and-bound method, as it will 
generally run much faster.  However, a nice feature of the exhaustive search is that it 
outputs a frequency distribution of tree lengths.

Although PAUP no longer enforces a limit on the maximum number of taxa that can be 
used in conjunction with the exhaustive search, expect long running times for 9 or 10 taxa.  
For more than 10 taxa, the number of trees becomes so astronomical that the exhaustive 
search will not generally be feasible.
This command requests Lake's method of invariants for nucleotide sequence data, called 
"evolutionary parsimony" by him.  It is only available if DATATYPE=RNA or 
DATATYPE=DNA is specified in the FORMAT command of the DATA block.

Lake's method uses quartets of taxa at a time.  You have three options for searching, and in 
each you must select which taxa will be included or excluded.  First, you can explicitly 
select four taxa to make up one search quartet.  When you do this, you must select the taxa 
you want and click on the Include button.  You can also double-click on a taxon to include 
or exclude it.  

The second option is to evaluate all possible quartets.  In that case you must choose which 
taxa will make up the group from which quartets will be taken.   The third option is to  
partition the taxa into four groups, which will then make up the quartet.  In that case,  you 
will have to select which taxa will be included in the groups, designated Group A through 
Group D.  Once a taxon has been assigned to a group, it is no longer available to be 
assigned to subsequent groups.   You can also specify the output that will appear in 
addition to the invariants: spectral components, branch lengths, or just summary tables. 
The Bootstrap command implements Felsenstein's bootstrap approach to placing 
confidence estimates on groups contained in the most parsimonious trees. 

Specify the number of replications desired, and change the random number seed if desired.  
If there are excluded characters or if all characters are not weighted equally, you must tell 
PAUP how to treat those characters during the bootstrap replicates. Indicate whether you 
want to perform an exact (branch-and-bound) or heuristic search by clicking on the 
appropriate button; then click on Continue.. A second dialog box will appear allowing you 
to specify search options.  The bootstrap procedure begins when you click the Bootstrap 
button of this second dialog box. 
Selecting  Random Trees will evaluate the length of the number of random trees chosen.  
The output will include a frequency distribution of tree lengths. 

This distribution can also be output to a file if you select Save tree-length frequency 
distribution to file. You can choose the random seed the PAUP presents or one of your 
own.   Usually, the box "Include ancestor" will be unchecked, unless you have defined an 
ancestor separate from the standard (all-missing) ancestor.  If not, all rootings will equally 
parsimonious and will be saved as distinct trees.
The Tree menu contains items for outputting trees and associated information, and for 
performing other tree-related activities.  See the following screens for further information.
The "Tree Info" command provides a quick summary of the number of trees currently in 
memory and how they were obtained.
This option will clear all trees in memory.
By default, PAUP collapses branches whose maximum length is zero, yielding polytomous 
trees.  However, you may choose to override this default, so that only completely 
bifurcating trees are produced during a search.  You can use the "Condense Trees" 
command to retroactively collapse zero-length branches and keep only those trees that are 
unique after the collapsing is accomplished.
"Root Trees..." and "Deroot Trees..." are specialized commands that are ordinarily 
unnecessary.  However, if you have unrooted trees stored in memory and you change one 
or more character types to a type that requires rooted trees (e.g., irreversible characters), 
the trees will have to be rooted before they can be output.  Trees are rooted via outgroup 
rooting using the outgroup in effect at the time the command is issued.
  
If you are using Lundberg rooting, you can select the ancestor with the pull-down menu.  
Selecting "Rooting Options..." will bring up the standard "Rooting..." dialog box.

Note that when you convert rooted trees to unrooted trees, trees that were formerly distinct 
may become equivalent.  You can use the "Condense Trees" command to eliminate these 
duplicate trees.
This command produces a matrix of tree-to-tree distances computed according to the 
symmetric-difference or "partition" metric.

The Compare options allow you to output distances for all trees to all other trees, or for all 
trees relative to a selected tree.  Clicking on the "Show all distances" checkbox will output a 
distance matrix for all selected trees, while clicking on the "Show frequency distribution" 
will only output a frequency distribution of tree distances.  Trees that are most similar will 
have the lowest distance value.  The output is very useful in identifying "classes" of similar 
trees. 
This outputs length and fit measures of all trees currently in memory and/or lengths and fit 
measures of individual characters on these trees.  Tree measures include the consistency 
index (CI), homoplasy index (HI), retention index (RI), and rescaled consistency index 
(RC).  

For individual character output, you may choose to see the fit measures for all characters or 
you may restrict the output to only those characters which vary over the trees in memory.  
This latter information is useful in judging which characters or sets of characters provide 
support for which trees.  If you have a number of trees in memory from different searches, 
this is a very good summary of character support for each rival tree. 
Use "Filter Trees" to temporarily limit available trees to those that satisfy certain criteria.  
These criteria can include (1) trees less than or equal to a certain length, (2) trees greater 
than or equal to a certain length, (3) trees that satisfy a particular constraint specification, 
(4)  trees that fail to satisfy a particular constraint specification, or (5) trees that are either 
less than or greater than a certain number of partition-metric units from a reference tree.

There are many potential applications for tree filtering.  For example, you may choose to 
save nonminimal trees during a search (via a "keep" length) and then subsequently obtain 
consensus trees showing the information common to only the shortest trees, trees within 
one step of the shortest, and so on.  Also, if a search finds a great many trees, you can 
check (via the constraints criterion) if particular groups occur on all or some of them.  
Finally, you can select suites of similar trees using the partition-metric criteria (or 
alternatively, find trees that are very different from a particular tree).  Use your 
imagination.
"Remove Filter" reverses the effect of a previous "Filter Trees" command, making all trees 
in memory available once again.
The Reverse Filter command simply reverses the filter status.  Trees formerly hidden by the 
filter become available, and vice versa.
Use this command to quickly output trees without associated character information.  If the 
trees are unrooted, the current rooting method (set via "Rooting" in the Options menu) is 
used to root the trees.
Use this command to output trees with associated statistics and/or character information.

Available information includes a list of apomorphies (character changes by branch); list of 
changes (character change by character); table of linkages (assigned, minimum, and 
maximum branch lengths); character diagnostics (goodness-of-fit statistics for each 
character; states for terminal taxa; states for internal nodes; possible state assignments; the 
f-value of Farris for each tree chosen; a patristic distance matrix between taxa; and finally a 
pairwise homoplasy index.  No matter what character information is selected, a tree will 
always be output, along with basic tree statistics.  This is the one of the best places to 
explore where characters changed on a tree and which nodes are supported by which 
characters.  Keep in mind that the output for many of these options will directly be a 
function of the method of optimization chosen.
This command produces either (a) a plot of the chosen tree(s) with the current 
reconstruction for each selected character "mapped" onto the tree ("Character changes"), or 
(b) a plot of the chosen tree(s) with the states that could be assigned to each internal node in 
at least one most parsimonious reconstruction ("Possible states assignments"). 
This command brings up a complicated dialog box that gives you wide control over the 
printing of trees in memory.  

Under the "Plot type" menu, you can select the basic form of the plot, whether a 
phylogram, circletree, or cladogram (rectangular or slanted).  You must also choose a tree 
or range of trees from those in memory, and optionally include the tree number and branch 
lengths in the output.  If there are multiple trees, you may wish to save space by printing 
more than one tree on a page.  This is done using the "Trees per Page" option.

The main "Print Trees..." menu also allows you to choose font type and size and line size 
for the plots.  These may take some adjusting if your are printing multiple trees per page, 
and some experimentation is usually necessary to get the best results.  The More options... 
button allows you to select taxon-label orientation, details of CircleTree display, and 
whether or not the output will be in PostScript format.

Due to the limitations of Macintosh graphics at 72 dpi, CircleTrees do not print very well 
unless you print directly to a PostScript printer, so use a LaserWriter for best results.

Up to 225 trees can be printed on a page, with or without tree numbers.  You can also 
change how the trees are rooted when they are printed, using outgroup, Lundberg, or 
midpoint rooting. If outgroup rooting is chosen, the outgroup can be rooted at an internal 
node with a basal polytomy, or the ingroup can be made monophyletic relative to the 
outgroup.  If there is more than one outgroup present, the tree can be rooted so that the 
outgroup is either paraphyletic relative to the ingroup, or a monophyletic sister-group to the 
ingroup. 

Once you have selected the display options you prefer, the "Preview" button allows you to 
see what the output will look like without printing.  It is useful to toggle back and forth 
between the Preview menu and the main selection menu to fine-tune your selections.  You 
also have the option in "Preview" to copy the image to a PICT file (which can be opened by 
any Macintosh graphics program) or to the clipboard (from which it can be pasted into an 
open window of a graphics application).  

If you plan to import the image to an application which cannot import PICT files, use 
"Copy to Clipboard".  Neither "PICT file" nor "Copy to Clipboard" requires that you 
actually print the image. 
An additional set of tree-printing options allows you to set the angle of rotation of taxon 
labels and to fine-tune the layout of circle-tree plots.  You can specify whether you want the 
taxon labels to be drawn horizontally or radially (extending outward in a spoke-like 
fashion).  If the "extent" is "full" the entire circumference of the circle will be used for the 
tree plot.  A value less than 360 will use proportionally less of the circumference and leave 
a "wedge" in which no drawing occurs.  Other options are self-explanatory.
Use the Compute Consensus command to compute consensus.  You will usually compute 
the consensus for all trees currently in memory, but you can select a subset if desired.

Available consensus techniques are semistrict, strict, Adams, and majority rule.  You can 
include consensus indices, and output the consensus to a treefile of your choosing. 
This allows you to specify the format of the Consensus when it is printed. The options are 
generally the same as for the Print Trees... command.  However, for majority-rule 
(including Bootstrap) consensus trees, you can request that the group frequencies be drawn 
on branch labels. 
Use this command to read trees from a file containing a NEXUS "trees" block into 
memory.  By default, all trees in the file will be read in.  Alternatively, by clicking the 
"Options..." button, you may specify a range of trees to import or you may use Boolean 
operations to select which trees are to be retained.  The Boolean operations are controlled 
using the Venn diagram provided. The  circle on the left represents the trees in memory; the 
one on the right represents the trees in the file.  When a circle or a segment of it is dark, that 
means the trees in that region will be kept.
Use this command to save some or all trees currently in memory to a file in NEXUS, 
PHYLIP, FREQPARS, or Hennig86 formats.  The file format is chosen using the pull-
down menu in the Format... option.

You can choose to root the trees before saving by clicking on the Root trees before saving 
checkbox (not available for FREQPARS format).  If you do select the "Root trees before 
saving" checkbox, the "Rooting Options..." button becomes active, and selecting it will 
bring up the standard "Rooting..." dialog box.  You can include branch length information 
by clicking on the "Include branch lengths" checkbox, but only if the file format is NEXUS 
or PHYLIP.  NEXUS files can also be saved with or without a translation table.  If a 
translation table is selected, PAUP will include a table that maps tokens in the tree 
specification to valid taxon names.
Command names may be entered in any combination of upper- and lower-case characters.  
A command name may be truncated freely so long as the resulting abbreviation remains 
unambiguous.  For example, the RESTORE command can be entered as "RESTORE", 
"restore", "Rest", or "RES", but it cannot be entered as "RE" (which also matches 
"REWEIGHT").  The command-listings generated by HELP and HELP COMMANDS 
show the shortest acceptable abbreviations in all-upper-case.

Many commands permit or require additional information to be specified.  This additional 
information generally takes the form "=" or simply "