# MAFFT

In bioinformatics, MAFFT (multiple alignment using fast Fourier transform) is a program used to create multiple sequence alignments of amino acid or nucleotide sequences. Published in 2002, the first version used an algorithm based on progressive alignment, in which the sequences were clustered with the help of the fast Fourier transform. Subsequent versions of MAFFT have added other algorithms and modes of operation, including options for faster alignment of large numbers of sequences, higher accuracy alignments, alignment of non-coding RNA sequences, and the addition of new sequences to existing alignments.

## History

There have been many variations of the MAFFT software, some of which are listed below:
* MAFFT – The first version, created by Kazutaka Katoh in 2002, used an algorithm based on progressive alignment, in which the sequences were clustered with the help of the fast Fourier transform.
* MAFFT v5 – The second generation software, released in 2005, was a rewrite of the original software. This generation introduced a simplified scoring system that performs well for reducing CPU time and increasing accuracy of alignments even for sequences having large insertions or extensions as well as distantly related sequences of similar length.
* MAFFT v6 – The third generation, released in 2006, again improved on prior versions. It implemented group-to-group alignment, guide trees which had an approximate but faster O(N log N) tree-building algorithm, and made the version usable with larger datasets of ~50,000 sequences.
* MAFFT v7 – The fourth generation, released in 2012, improved the speed and accuracy substantially.
* MAFFT v7.511 – A more recent version, released in December 2022, improved on version 7 with various bug fixes. One of the most notable being an overhaul to the --merge option, which now includes, enabling iterative refinement, creating a single MSA from multiple sub-MSAs, as well as the combination of --merge and --seed. There were also several minor enhancements to the speed and accuracy of MAFFT v7.

## Algorithm

The MAFFT algorithm works following these 5 steps Pairwise Alignment, Distance Calculation, Guide Tree Construction, Progressive Alignment, Iterative Refinement.
* Pairwise Alignment – This step is used to identify the regions that are similar between the sequences inputted. The algorithm starts by using the inputted sequences executing pairwise alignments across all the sequences. This step's time complexity is O(L^2) where L is the sequence.
* Distance Matrix – Using the calculated pairwise alignments, a distance matrix calculation is done to evaluate the dissimilarity between the alignments based on their alignment scores. The distance calculation step helps organize the sequences based on their similarity. The Distance Matrix's time complexity is O(N^2L^2) where N is the number of sequences and L is the length of the sequence. This time complexity is because the distance calculation between pairs of sequences requires comparing every position of each sequence.
* Guide Tree – Using the distance matrix a guide tree is constructed where there is a hierarchical representation of the clusters (each node is a cluster) and the branches included are the distance between the clusters. O(N^2L) is the time complexity for the guide tree construction, where N is the number of sequences.
* Progressive Alignment – Using the guide tree progressive alignment is performed from the leaves to the root. The algorithm uses the inputted sequences and aligns the child nodes to calculate a consensus alignment for the parent node. This step is done until the entire tree is traversed to result a final multiple sequence alignment. The progressive alignment method's time complexity is O(N^2L) + O(NL^2). This is because the first term corresponds to the guide tree calculation stated earlier along with the second term that corresponds to group to group alignment.
* Iterative Alignment – The iterative refinement step repeats the entire process with adjustments to the positions of gaps and insertions to improve alignment accuracy. The time complexity of the iterative alignment depends on the number of iterations that occur. But generally the time complexity of this method is O(N2L) + O(NL2) where N is the number of sequences, and L is the length of the sequence.

## Input/output
### Web form
#### Input

This program can take in multiple sequences as input, which can be entered in two ways:

##### Sequence input window

The user can directly enter three or more sequences in the input window in any of the following formats: GCG, FASTA, EMBL (nucleotide only), GenBank, PIR, NBRF, PHYLIP, or UniProtKB/Swiss-Prot (protein only). It is important to note that partly formatted sequences are not accepted, and adding a return to the end of the sequence may help certain applications understand the input. It is also advised to avoid using data from word processors as hidden/control characters may be present.

##### Sequence file upload

The user can upload a file containing three or more valid sequences in any format mentioned above. Word processor files may yield unpredictable results due to the presence of hidden/control characters, so it is best to save files with the Unix format option to avoid hidden Windows characters. Once the file is uploaded, it can be used as input for multiple sequence alignment.
Text files saved on DOS and Windows format have different line endings than those saved on Unix and Linux. DOS–Windows uses a combination of carriage return and line feed characters ("\r\n") to indicate the end of a line, while Unix–Linux systems use only a line feed character ("\n").
When transferring files between Windows and Unix-based systems, it's important to be aware of these differences to ensure that the line endings are correctly translated. Otherwise, the hidden carriage return characters in the Windows-formatted files may cause issues when viewed or edited on Unix-based systems, and vice versa.

#### Output

The user will have the option to request the Multiple Sequence Alignment (MSA) to be generated in one of the two available formats:
| Output format | Description | Abbreviation |
| Pearson/FASTA | Pearson or FASTA sequence format | fasta |
| ClustalW | ClustalW alignment format without base/residue numbering | clustalw |
Default value is: Pearson/FASTA [fasta]
Understanding ClustalW output: :
| Symbol | Definition | Meaning |
| * | asterisk | Conserved sequence (identical) |
| : | colon | Conservative mutation |
| . | period | Semi-conservative mutation |
| ( ) | blank | Non-conservative mutation |
| - | dash | Gap |

## Settings

There are many settings that affect how the MAFFT algorithm works. Adjusting the settings to needs is the best way to get accurate and meaningful results. The most important settings to understand are: the Scoring Matrix, Gap Open Penalty, and Gap Extension Penalty.
* Scoring Matrix – Protein sequence similarity searching programs like BLASTP, SSEARCH (UNIT 3.10), and FASTA use scoring matrices that are designed to identify distant evolutionary relationships (BLOSUM62 for BLAST, BLOSUM50 for SEARCH and FASTA). Different similarity scoring matrices are most effective at different evolutionary distances. “Deep” scoring matrices like BLOSUM62 and BLOSUM50 target alignments with 20 – 30% identity, while “shallow” scoring matrices (e.g. VTML10 – VTML80), target alignments that share 90 – 50% identity, reflecting much less evolutionary change." In original MAFFT the scoring equation is shown below.
* Gap Open Penalty – A gap penalty is a negative score assigned to a gap in an alignment. It can be constant, where a fixed cost is charged for the gap, or linear, where a fixed cost is charged for each symbol inserted or deleted. An affine gap penalty combines the two by charging a constant penalty for the first symbol of a gap and another constant penalty for each additional symbol inserted or deleted.
* Gap Extension Penalty – Gap extension penalty is a cost score assigned for each additional gap symbol in a gap region in sequence alignment. It is used to discourage the formation of long gap regions. It is typically smaller than the gap opening penalty.

## Accuracy and results

MAFFT is widely considered to be one of the most accurate and versatile tools for multiple sequence alignment in bioinformatics. In fact, studies have shown that MAFFT performs exceptionally well when compared to other popular algorithms such as ClustalW and T-Coffee, particularly for larger datasets and sequences with high degrees of divergence. For example, in a study comparing performance of various alignment algorithms on increasing sequence lengths, MAFFT's FFT-NS-2 algorithm was found to be the fastest program for all tested sequence sizes. This is due to its use of fast Fourier transform (FFT) algorithms, which enable rapid and accurate alignment of even highly divergent sequences. Because of the use of fast Fourier transform (FFT) the algorithm runs in either O(n^2) or O(n) depending on the given data set. MAFFT takes less CPU runtime than other algorithms that have the same or similar accuracies especially T-Coffee, ClustalW, and Needleman-Wunsch.
Later versions of MAFFT have added other algorithms and modes of operation, including options for faster alignment of large numbers of sequences, higher accuracy alignments, alignment of non-coding RNA sequences, and the addition of new sequences to existing alignments.
MAFFT stands out among other popular algorithms such as ClustalW and T-Coffee due to its high accuracy, versatility, and range of features. It offers various alignment methods and strategies, including iterative refinement and consistency-based approaches, that further enhance accuracy and robustness of alignments. As a result, MAFFT is widely recognized as a powerful tool for multiple sequence alignment and is highly appreciated by the scientific community.