Pairwise-Alignment on CuriousCoding

Thoughts on Singletrack

Tue, 04 Nov 2025 00:00:00 +0100

This is a quick post summarizing the idea of “Singletrack: An Algorithm for Improving Memory Consumption and Performance of Gap-Affine Sequence Alignment” by López-Villellas, Iñiguez, Jiménez-Blanco, Aguado-Puig, Moretó, Alastruey-Benedé, Ibáñez, and Marco-Sola to reduce memory usage of affine-cost alignment by removing the need to store the affine layers of the DP matrix.

Affine-cost alignment uses a gap-open cost \(o>0\), so that a gap of length \(\ell\) has cost \(o + \ell \cdot e\). The classic DP solution for this is Gotoh’s method (Gotoh 1982) that uses two additional DP matrices \(I\) and \(D\) (alongside the main \(M\) matrix): one to store the best cost to get to state \((i,j)\) while ending in an insertion, and one that ends with a deletion.

A History of Pairwise Alignment

Wed, 09 Apr 2025 00:00:00 +0200

Table of Contents

1 A Brief History
- 1.1 A*PA
- 1.2 A*PA2
- 1.3 Overview
2 Problem Statement
3 Alignment types
4 Cost Models
- 4.1 Minimizing Cost versus Maximizing Score
5 The Classic DP Algorithms
6 Linear Memory using Divide and Conquer
7 Dijkstra’s Algorithm and A*
8 Computational Volumes and Band Doubling
9 Diagonal Transition
10 Parallelism
11 LCS and Contours
12 Some Tools
13 Subquadratic Methods and Lower Bounds
14 Summary

This is Chapter 2 of my thesis (Groot Koerkamp 2025), to introduce the first part on Pairwise Alignment. Please cite the thesis instead of this post.

Beyond Global Alignment

Mon, 07 Apr 2025 00:00:00 +0200

Table of Contents

1 Variants of semi-global alignment
2 Fast text searching
- 2.1 Skip-cost for overlap alignments
- 2.2 Results
3 Mapping using A*Map
- 3.1 Seeding
- 3.2 Chaining
- 3.3 Aligning
- 3.4 A*Map
- 3.5 Results

This is Chapter 5 of my thesis (Groot Koerkamp 2025). Please cite the thesis instead of this post.

Summary

So far, we have considered only algorithms for global alignment. In this chapter, we consider semi-global alignment and its variants instead, where a pattern (query) is searched in a longer string (reference). There are many flavours of semi-global alignment, depending on the (relative) sizes of the inputs. We list these variants, and introduce some common approaches to solve this problem.

Path Pruning Revisited

Mon, 31 Mar 2025 00:00:00 +0200

Table of Contents

1 Early idea: Bottom-up match-merging (aka BUMMer?)
- 1.1 Some previous ideas
- 1.2 Divide & conquer
- 1.3 Bottom-up match merging (BUMMer)

1 Early idea: Bottom-up match-merging (aka BUMMer?) Link to heading

TODO: Move to separate post.

One thing that becomes clear with mapping is that we don’t quite know where exactly to start the semi-global alignments. This can be fixed by adding some buffer/padding, but this remains slightly ugly and iffy.

Thoughts on POASTA

Tue, 28 May 2024 00:00:00 +0200

Table of Contents

Summary
Background
Review comments

Here are some thoughts on POASTA (van Dijk et al. 2024), a recent affine-cost sequence-to-DAG (POA) aligner inspired by WFA and using A*.

Summary Link to heading

Take a query and a directed acyclic graph (DAG).
Align the query to the full DAG. It’s like global alignment for graphs.
- In fact I think the graph doesn’t actually have to be acyclic, as long as it has a start and end. (When there is a cycle, the maximum remaining path length is simply \(\infty\).)
Do greedy extension of matches, similar to WFA and A*PA.
- Note that this is not as strong as full diagonal transition as done by WFA and gWFA (graph WFA for unit costs only), which only consider farthest reaching states.
In fact, this is the first implementation of affine-cost WFA!
It also uses A* with the classic gap-cost heuristic extended to graphs.
- For each point in the graph the minimal and maximal remaining distance is computed, and if the remaining query length is outside this range, the difference to get into the range is a lowerbound on number of indels.
Greedy extension is applied (although this is inherent when using WFA).
Suboptimal states in superbubbles are pruned using additional logic.

Background Link to heading

Daniel: why is nobody doing exact banded alignment, i.e., simple band doubling, for exact DP-based alignment. We are still not convinced that A*/WFA is faster than DP, especially when divergence is not super low (\(<1\%\)).

Review comments Link to heading

Fig 1 confuses me: (partly Daniel)

A*PA2: Up to 19x faster exact global alignment

Sat, 23 Mar 2024 00:00:00 +0100

Table of Contents

Abstract
1 Introduction
- 1.1 Contributions
- 1.2 Previous work
  - 1.2.1 Needleman-Wunsch
  - 1.2.2 Graph algorithms
  - 1.2.3 Computational volumes
  - 1.2.4 Parallelism
  - 1.2.5 Tools
2 Preliminaries
3 Methods
- 3.1 Band-doubling
- 3.2 Blocks
- 3.3 Memory
- 3.4 SIMD
- 3.5 SIMD-friendly sequence profile
- 3.6 Traceback
- 3.7 A*
  - 3.7.1 Bulk-contours update
  - 3.7.2 Pre-pruning
- 3.8 Determining the rows to compute
  - 3.8.1 Sparse heuristic invocation
- 3.9 Incremental doubling
4 Results
- 4.1 Setup
- 4.2 Comparison with other aligners
- 4.3 Effects of methods
5 Discussion
Acknowledgements
Conflict of interest
6 Appendix
- 6.1 Bitpacking
- 6.2 Comparison with other aligners
- 6.3 Effects of methods

\begin{equation*} \newcommand{\g}{g^*} \newcommand{\h}{h^*} \newcommand{\f}{f^*} \newcommand{\cgap}{c_{\textrm{gap}}} \newcommand{\xor}{\ \mathrm{xor}\ } \newcommand{\and}{\ \mathrm{and}\ } \newcommand{\st}[2]{\langle #1, #2\rangle} \newcommand{\matches}{\mathcal M} \end{equation*}

A*PA talk @ CWI

Wed, 27 Dec 2023 00:00:00 +0100

I recently gave a talk about A*PA at CWI. Sadly the recording doesn’t show the blackboard, but either way, find it here.

BitPAl bitpacking algorithm

Sun, 03 Sep 2023 00:00:00 +0200

Table of Contents

Problem
Input
Example
Discussion
Found the bug
Outlook

The supplement (download) of the Loving, Hernandez, and Benson (2014) paper introduces a \(15\) operation version of Myers (1999) bitpacking algorithm, which uses \(16\) operations when modified for edit distance.

I tried implementing it, but it seems to have a bug that I will describe below. The fix is here.

Problem Link to heading

To recap, this algorithm solves the unit-cost edit distance problem by using bitpacking to compute a \(1\times w\) at a time. As input, it takes

Shortest paths, bucket queues, and A* on the edit graph

Sat, 29 Jul 2023 00:00:00 +0200

Table of Contents

Shortest path algorithms ..
- .. in general
- .. for circuit design
Bucket queues
Shortest path algorithms by Hadlock
- Grid graphs
- Strings
Spouge’s computational volumes

This note summarizes some papers I was reading while investigating the history of A* for pairwise alignment, and related to that the first usage of a bucket queue. Schrijver (2012) provides a nice overview of general shortest path methods.

The complexity and performance of WFA and band doubling

Thu, 17 Nov 2022 00:00:00 +0100

Table of Contents

Complexity analysis
Implementation efficiency
- Band doubling for affine scores was never implemented
WFA vs band doubling for affine costs
Conclusion
- Future work

This note explores the complexity and performance of band doubling (Edlib) and WFA under varying cost models.

Edlib (Šošić and Šikić 2017) uses band doubling and runs in \(O(ns)\) time, for sequence length \(n\) and edit distance \(s\) between the two sequences.

Local Doubling

Wed, 19 Oct 2022 00:00:00 +0200

Table of Contents

Notation
Needleman-Wunsch: where it all begins
Dijkstra/BFS: visiting fewer states
Band doubling: Dijkstra, but more efficient
GapCost: A first heuristic
Computational volumes: an even smaller search
Cheating: an oracle gave us \(g^*\)
A*: Better heuristics
Broken idea: A* and computational volumes
Local doubling
- Without heuristic
- With heuristic
Diagonal Transition
A* with Diagonal Transition and pruning: doing less work
Goal: Diagonal Transition + pruning + local doubling
Pruning: Improving A* heuristics on the go
Cheating more: an oracle gave us the optimal path
TODO: aspriation windows

\begin{equation*} \newcommand{\st}[2]{\langle #1,#2\rangle} \newcommand{\g}{g^*} \newcommand{\fm}{f_{max}} \newcommand{\gap}{\operatorname{Gap}} \end{equation*}

Competitive Programming Lecture

Wed, 28 Sep 2022 00:00:00 +0200

Table of Contents

Contest strategies
Pairwise Alignment using A*
Exercises

Contest strategies Link to heading

Preparation

Thinking costs energy!
Sleep enough; early to bed the 2 nights before.
No practising on contest day (and the day before); it just takes energy.

During the contest

Eat! At the very least take a break halfway with the entire team and eat some snacks.
Make sure to read all the problems before the end of the contest. In the beginning, split the problems to find the simple ones, but towards the end, find a problem you think you can solve (because of the scoreboard or because you like it), and work on it as a team.

Coding

Ideally, use C++. Otherwise, Python can be used too.
- For big-integer problems, prefer Python.
Use a TCR (e.g. https://github.com/TimonKnigge/TCR): a 25 page document containing algorithms. Ideally, implement all of them yourself so you know how they work. Otherwise download one.
Make a template, and add it to your TCR. One person should type this in the first minutes of the contest and copy it to A.cpp, B.cpp, … .
When you think you solved a problem:
- Decide exactly how the code will look. Maybe write pseudocode on paper.
- For hard problems: verify your solution with a teammate.
- Once the keyboard is free, start typing it out. If needed, ask one teammate to look while you code.
- Typical distribution:
  - 1 person typing
  - 1 person solving a new problem
  - 1 person helping the other 2: spotting typos or working on problems.

Pairwise Alignment using A* Link to heading

Some resources you can use:

Speeding up A*: computational volumes and path-pruning

Fri, 23 Sep 2022 00:00:00 +0200

Table of Contents

Motivation
Summary
Why is A* slow?
Computational volumes
Dealing with pruning
- Thoughts on more aggressive pruning
Algorithm summary
Challenges
Results
What about band-doubling?
- Maybe doubling can work after all?
TODOs
Extensions

This post build on top of our recent preprint Groot Koerkamp and Ivanov (2024) and gives an overview of some of my new ideas to significantly speed up exact global pairwise alignment. It’s recommended you understand the seed heuristic and match pruning before reading this post.

Linear memory WFA?

Wed, 17 Aug 2022 00:00:00 +0200

Table of Contents

Motivation
Path traceback: two strategies
Observations
- What information is needed for path tracing
A pragmatic solution
Another interpretation
Affine costs
Conclusion

Figure 1: Only the red substitutions and blue indel need to be stored to trace the entire path.

Transforming match bonus into cost

Tue, 16 Aug 2022 00:00:00 +0200

Table of Contents

Tricks with match bonus or how to fool Dijkstra’s limitations
Conclusion

Tricks with match bonus or how to fool Dijkstra’s limitations Link to heading

The reader is assumed to have basic knowledge about pairwise alignment and graph theory.

Diamond optimisation for diagonal transition

Mon, 01 Aug 2022 00:00:00 +0200

Table of Contents

Diamond transition or how technicalities can break concepts
- But let’s take a closer look
- Conclusion

Diamond transition or how technicalities can break concepts Link to heading

We assume the reader has some basic knowledge about pairwise alignment and in particular the WFA algorithm.

In this post we dive into a potential 2x speedup of WFA — one that turns out not to work.

The BiWFA meeting condition

Mon, 11 Jul 2022 00:00:00 +0200

cross references: BiWFA GitHub issue

It seems that getting the meeting/overlap condition of BiWFA (Marco-Sola et al. (2023), Algorithm 1 and Lemma 2.1) correct is tricky.

Let \(p := \max(x, o+e)\) be the maximal cost of any edge in the edit graph. As in the BiWFA paper, let \(s_f\) and \(s_r\) be the distances of the forward and reverse fronts computed so far.

We prove the following lemma:

Lemma Once BiWFA has expanded the forward and reverse fronts up to \(s_f\) and \(s_r\) and has found some path of cost \(s \leq s_f + s_r\), expanding the fronts until \(s’_f + s’_r \geq s+p+o\) is guaranteed to find a shortest path.

Proof sketch for linear time seed heuristic alignment

Sun, 24 Apr 2022 00:00:00 +0200

Table of Contents

Pairwise alignment in subquadratic time
Random model
Algorithm
- Seed heuristic
- Match pruning
Analysis
- Expanded states
  - Excess errors
- Algorithmic complexity

This post is a proof sketch to show that A* with the seed heuristic (Groot Koerkamp and Ivanov 2024) does exact pairwise alignment of random strings with random mutations in near linear time.

Pairwise alignment in subquadratic time Link to heading

Backurs and Indyk (2018) show that computing edit distance can not be done in strongly subquadratic time (i.e. \(O(n^{2-\delta})\) for any \(\delta >0\)) assuming the Strong Exponential Time Hypothesis.

Variations on the WFA recursion

Sun, 17 Apr 2022 03:14:00 +0200

Table of Contents

Gap open
Gap close
Symmetric alternatives
Another symmetry
Conclusions

cross references: BiWFA GitHub issue

In this post I will explore some variations of the recursion used by WFA/BiWFA for the affine version of the diagonal transition algorithm. In particular, we will go over a gap-close variant, and look into some more symmetric formulations.

Gap open Link to heading

WFA (Marco-Sola et al. 2021) introduces the affine cost variant of the classic diagonal transition method. Let us call it a gap-open variant, because the gap-open cost \(o\) is payed when opening the gap, that is, when jumping from the \(M\) layer to the \(I\) or \(D\) layer.

A survey of exact global pairwise alignment

Fri, 01 Apr 2022 00:00:00 +0200

This post explains the many variants of pairwise alignment, and covers papers defining and exploring the topic.

AStarix

Fri, 12 Nov 2021 13:05:00 +0100

Papers

AStarix is a method for aligning sequences (reads) to graphs:

Input

A reference sequence or graph
Alignment costs \((\Delta_{match}, \Delta_{subst}, \Delta_{del}, \Delta_{ins})\) for a match, substitution, insertion and deletion
Sequence(s) to align

Output

An optimal alignment of each input sequence

The input is a reference graph (automaton really) \(G_r = (V_r, E_r)\) with edges \(E_r \subseteq V_r\times V_r\times \Sigma\) that indicate the transitions between states.