Preliminary Definitions

A string is a sequence of elements on an alphabet , where the alphabet is a non-empty finite set of letters of size . We denote with the empty character (a character whose presence does not change the string it is in), and with the empty string: a string made up of empty characters only.

A string containing one or more empty characters is an elastic string. The set of all finite strings over an alphabet , including the empty string of length , is denoted by , while denotes the set . For any string , we denote by the substring of that starts at position and ends at position . In particular, is the prefix of that ends at position , and is the suffix of that starts at position , where denotes the length of .

When , then as well, and in that case is just a simple letter of and we say that is solid, and else we say that it is a degenerate position. The following parameters measure the degeneracy of an ED-string: the total size and total width of an ED-string are respectively defined as and .

For example, in Equation 1 has length , , and . Moreover, we have that all positions are solid except for and , and hence all ’s are equal to except and , and therein we have .

Edit Distance with Skips

According to the traditional dynamic programming framework, we incrementally compute the optimal alignments of prefix of against prefix () of starting with and/or equal to up to the final lengths.

The affine gap penalty function in sequence alignments accounts to a gap of size the cost , where is the opening cost, and is the extension cost. The problem of computing the optimal alignment with such gap penalty function does not directly fulfill the requirement of having optimal substructure (needed to apply dynamic programming), and to overcome this limitation, the alignment is conceptually split in blocks grouping runs of edit events. To this purpose, the computation of an optimal alignment with affine gap penalty function requires to replicate the matrices: () for insertions, () for deletions, () for (mis)matches. Since the skip operation we want to implement raises a similar issue, we here add an additional matrix () for skips. The skip operation is contemplated when includes the empty string, and it carries a cost of zero because it does not actually change and can be thought of as a free insertion.

Let us assume for now that we want to optimally align a string with with an elastic string using the scores: (match), (skip), (mismatch), (gap opening), (gap extend).

We extend the existing model by adding a skip (S) operation that inserts at no cost when this is an empty character. We therefore end up having edit operations M (for match), X (for mismatch), I (for insertion of ), D (for deletion of ), and S (for skipping ), and with the dynamic programming matrices of size with the following meanings:

Matrix	Description
	score of best alignment of and ending with (mis)match
	score of best alignment of and ending with a skip of
	score of best alignment of and ending with an insertion of
	score of best alignment of and ending with a deletion of

The initialization of all matrices is as follows:

• : Like in traditional dynamic programming with affine gap penalty, we have and because no alignment of and can end with a match or mismatch.
• : Again like in traditional dynamic programming with affine gap penalty, we have because we align an empty prefix of with , while because no alignment of and the empty prefix of can end with a deletion in .
• : Dually, because no alignment of an empty prefix of and can end with an insertion of a letter of . Let be the smallest from to such that . Then we have:

we need to align and the empty prefix of ending with an insertion of , and this is only possible if , and it either extends an existing gap that was already open at row , or it extends one that was opened earlier and has included a skip.

• : We have that because no alignment of an empty prefix of and can end with a skip of , while:

because we need to align and the empty prefix of ending with a skip, and this latter is not possible if . On the other hand, when , then either a skip had occurred already at the previous row (in which case we inherit its score), or we have to inherit the score of an insertion gap.

We can then progressively fill in the matrices for as follows:

where:

The deletion matrix is the exact same as in traditional alignment:

The insertion matrix is as follows:

And finally, the skip matrix recurrences:

We then have that the final result is .

Correctness of the Recurrence

Using Figure 1, and given the existing proofs apply for edit distance in general and cases: 1 (alignment ends in an insertion), 2 (alignment ends in a deletion), and 3 (alignment ends in a match or a mismatch) (F.Smith and S.Waterman 1981; O.Gotoh 1982; D.Gusfield 1997).

Lemma 1 When we can insert a skip for free.

Proof. In case 4, when . If the last symbol in the edit transcript is , inductively the alignment up to and computes the optimal edit distance between and . Because , we can insert after without actually changing , then .

Edit Distance with an Elastic Degenerate String

Standard Partial Order Alignment (POA) collapses paths containing deletions, which hides the historical length differences of variants. This causes traceback ambiguity. By introducing a directed “Skip” edge (), we preserve the exact variant topology without penalizing the alignment.

graph LR
    %% Subgraph A: Standard POA
    subgraph A[" "]
        node1((A)) -->|Match / Mismatch| node2((T))
        node1 -->|Deletion Path Collapsed| node2
        
        %% Label pushed to the bottom of subgraph A
        labelA["<b>(a) Standard POA (Ambiguous)</b>"]
    end

    %% Subgraph B: Skip-Enhanced POA
    subgraph B[" "]
        node3((A)) -->|Match / Mismatch| node4((T))
        node3 -.->|0-cost Skip ε| skip[Skip State]
        skip --> node4
        
        %% Label pushed to the bottom of subgraph B
        labelB["<b>(b) Skip-Enhanced POA (Resolved)</b>"]
    end

    %% Styling to make labels look like clean captions and push them down
    style labelA fill:none,stroke:none,font-weight:bold
    style labelB fill:none,stroke:none,font-weight:bold
    style skip stroke-dasharray: 5 5, fill:#e1f5fe, stroke:#0288d1

We can index an MSA column-wise, each column being one base wide, being the left-most and as the right-most column. After converting this MSA into an ED-String we can apply the same indexing. In this case, a position in an ED-String , denoted is the set of characters at a locus if it were an MSA.

To align a string to an ED-String we pad shorter variants with until all variants are of equal length.

The cells of the dynamic programming (DP) table are tuples of size which correspond to the and functions (Equation 5) and (which behaves similarly to the skip function in Equation 8) would be extended to Equation 9 and Equation 10.

It then follows that the edit distance to position in a variant is given by . To get the edit transcript we traceback as usual.

Complexity

Given the size of the EDT is and the query is , we have space and time usage.

Discussion

The introduction of the skip operation (S) resolves a compromise in progressive Multiple Sequence Alignment (MSA) using Partial Order Alignment (POA). While standard POA successfully avoids collapsing alignments into a simple consensus string, its inability to trace distinct variant lengths introduces ambigiuty downstream.

Conclusion and Furture Directions

In this work, we resolved a limitation of Partial Order Alignment (POA): the ambiguity of the edit transcript during progressive Multiple Sequence Alignment. By introducing the skip operation () with a zero-cost penalty, we successfully decoupled path traversal from distance calculations. This ensures that existing gaps are not penalized repeatedly while still preserving the exact, unambiguous edit transcript.

Ultimately, viewing an MSA as an Elastic Degenerate String (ED-string) allows for lossless POA with respect to the edit transcript, overcoming a long-standing compromise in progressive sequence alignment.