Asymptotically faster algorithm for counting self-avoiding walks and self-avoiding polygons

TL;DR

This paper introduces a significantly faster algorithm for counting self-avoiding walks and polygons on lattices, with improved asymptotic runtime bounds in two and higher dimensions, advancing combinatorial enumeration methods.

Contribution

The paper presents a new algorithm with asymptotic runtime improvements for counting self-avoiding walks and polygons across various lattice dimensions.

Findings

Runs in time exp(C√(n log n)) for 2D lattices

Runs in time exp(C_d n^{(d-1)/d} log n) for d-dimensional lattices

Provides asymptotic bounds that outperform previous methods

Abstract

We give an algorithm for counting self-avoiding walks or self-avoiding polygons that runs in time $\exp(C\sqrt{n\log n})$ on 2-dimensional lattices and time $\exp(C_dn^{(d-1)/d}\log n)$ on $d$-dimensional lattices for $d>2$.

Equations

$$C(P)=$$

$$\text{ horizontal edges of the polygon crossing it}\}.$$

$$c_n=\sum _{K\subseteq \{0,\dots ,k-1\},K\ne \varnothing }(-1{)}^{|K|+1}{N}_K.$$

$$N$$

$$+N_{\{0,1,2\}}+N_{\{0,1,3\}}+N_{\{0,2,3\}}+N_{\{1,2,3\}}-N_{\{0,1,2,3\}}$$

$${\left(\genfrac{}{}{0ex}{}{n}{q}\right)}^2{2}^{k+1}$$

$$n^{O(1)}{\left(\genfrac{}{}{0ex}{}{n}{q}\right)}^2{2}^{k+1}{2}^{2q+k+1}\le 2^{O((n\log n)/k+k+\log n)}.$$

$$2^{O((n\log n)/k+k+\log n)}$$

$$\exp (C\sqrt{n\log n}).$$

$$\exp (C_d{n}^{(d-1)/d}\log n).$$

Full text

1 Introduction

Given a lattice, a self-avoiding walk (SAW) of length $n$ is a walk in the graph that starts at the origin and never revisits a vertex. A self-avoiding polygon (SAP) is a SAW except that it returns to the origin on the $n$th step (also, when talking about counting SAPs, we do not care about which point on the polygon is the origin). SAWs and SAPs are used as a model for polymers in statistical mechanics. A good source for information on SAPs and SAWs (current as of 1993) is [11].

It is strongly believed (but not proved) that the number of SAWs of length $n$ on a lattice is given by $c_{n}\sim An^{\gamma-1}\mu^{n}$ and the number of SAWs of length $n$ is given by $p_{n}\sim Bn^{\alpha-3}\mu^{n}$ where $\gamma$ and $\alpha$ are critical exponents depending only on dimension, while $\mu$ depends on the lattice, with $\mu\approx 2.6$ for the square lattice and $\mu\approx 4.7$ for the simple cubic lattice.

The naive algorithm for counting SAWs and SAPs is based on backtracking to list each individual path, so it has exponential complexity $\mu^{n}$. However, there have been a series of improved algorithms that run in time $C^{n}$ for various improved values of $C$ (omitting polynomial factors in the runtime). We will mostly just talk about the work for square and cubic lattices, since more work has been done on them and they are easier to work with, although there has been work on other lattices also. Most known algorithms can be adapted to any lattice of the same dimension. In [6], Enting first applied the transfer matrix method to this problem for the square lattice (we will describe the method more in the next section). Variants of this method have been developed. Most recently, Clisby and Jensen [1] counted all SAPs on the square lattice up to length 130 with an algorithm that had $C\leq 1.2$ (it improves over a previous algorithm [10] which had $C\approx 1.2$, but they do not specify what value of $C$ they have). Jensen [9] counted all SAWs of length up to 79 on the square lattice with an algorithm that had $C\leq 1.334$ (it improves over a previous algorithm [8] which had $C\approx 1.334$). There was also an algorithm for counting SAWs by Conway, Enting, and Guttman [3] that had $C=3^{1/4}\approx 1.316$, but it was slower in practice than Jensen’s algorithm.

On three dimensional lattices, the best previously known algorithm for SAWs is the doubling method of Schram, Barkina, and Bisseling [4, 5]. This method involves listing all self-avoiding walks of length $n/2$ and then using inclusion-exclusion to count nonintersecting pairs of such paths (corresponding to walks of length $n$). They have $C=\sqrt{2\mu}$ on any lattice, which for the cubic lattice gives $C\approx 3.06$ and allows them to count SAWs of length up to 36. The best count of SAPs for the cubic lattice is in [2], which goes up to length 32.

In Section 2, we give an algorithm for enumerating SAPs for all lengths up to $n$ on the square lattice that runs in $\exp(C\sqrt{n\log n})$ time. In Section 3, we explain how to modify the algorithm to count SAPs for all lengths up to $n$ on the lattice $\mathbb{Z}^{d}$ so that it runs in time $\exp(C_{d}n^{(d-1)/d}\log n)$. In Section 4, we give a few remarks on ideas for optimizing these algorithms for the square lattice for practical use.

This is a significant theoretical improvement over existing exponential-time algorithms. The algorithms presented here can, with minor modification, work for counting SAWs, as well as counting SAWs and SAPs with various statistics, or in certain convex regions in space, or on different $d$-dimensional lattices. The basic idea can probably also be used for some other transfer matrix enumeration problems, as long as the objects being counted are sparse in a suitable sense—in the case of SAPs, the sparsity lies in including only $n$ edges out of $\approx n^{2}$ potential edges in the rectangle.

2 Better algorithm for two dimensions

We present the following algorithm for counting self-avoiding polygons on $\mathbb{Z}^{2}$ in time

$\exp(C\sqrt{n\log n})$. With slight modifications that may affect the constant $C$, but not the form of the asymptotics, we can use the same algorithms to count self-avoiding walks, work on other lattices, count SAWs or SAPs restricted to some convex or relatively nice region of space, or count SAWs or SAPs satisfying certain statistics (such as mean square end-to-end distance for SAPs, or the sum of coordinates of vertices and sum of their squares, which together allow you to calculate the mean square distance between pairs of point vertices). Below, we will give a brief description of the transfer matrix method as applied to this problem, and then how we modify it. For a detailed description of how the transfer matrix algorithm works in the case of SAPs, see [1, 6, 7].

We will make no attempt in this section to optimize the constant $C$ in the runtime. The algorithm works based on the transfer matrix method. We will count SAPs inscribed in an $L$ by $W$ rectangle and then sum over $L,W\leq n$. At each step, we will have some set of vertices in a set $A$ so that if any vertex is in $A$, then the vertex to its left and above it are also in $A$. $A$ will start out with only vertices above and to the left of our rectangle, and we will add one vertex at a time to $A$. The state space will be the list of edges connecting $A$ to $\bar{A}$, how these edges are connected by paths inside $A$, how many edges of the SAP are contained inside $A$, and whether the part of the SAP contained in $A$ touches each of the four edges of the rectangle. For instance, one state is given by the figure below along with the caption.

If the number of states is $S$, then we will store a vector of $S$ numbers, namely how many arrangements inside $A$ achieve every one of the states. It is easy to come up with fast local rules for updating when a new vertex is added to $A$, and these rules are spelled out in detail in [1] for counting SAPs and in [9] for counting SAWs. These rules are equivalent to multiplying our state vector by some matrix, hence the name “transfer matrix method”. However, because all of the rules are local, this matrix is sparse, which speeds up the updating step. Previous algorithms [1, 9] to use the transfer matrix method updated $A$ by moving the boundary to the right one column at a time as follows (the red line shows the bottom right boundary of $A$):

Unfortunately, that led to them having exponential state space and thus exponential runtime (though better than the naive runtime).

We come up with a different way to move the boundary based on the following observation. Pick some $2\leq k<n$ and let $q=\lfloor n/k\rfloor$. For $P$ an SAP of length $n$ inscribed in our rectangle, let

[TABLE]

Then by the pigeonhole principle, $C(P)$ is nonempty. We count the number of SAPs with nonempty $C(P)$ (and thus the number of SAPs) using inclusion-exclusion. For each nonempty $K\subset\{0,\ldots,k-1\}$ it suffices to count the number of SAPs such that $K\subseteq C(P)$, and we will denote this count by $N_{K}$. We find $N_{K}$ by advancing the boundary of $A$ from column to column, skipping those columns whose number is $\beta$ mod $k$ for some $\beta\notin K$, and whenever we stop at a column that is $\alpha$ mod $k$ for $\alpha\in K$, we throw away those states that have more than $q$ edges crossing that column. For instance, if we skip one column, we do it as follows:

For example, if $k=6$ and $K=\{1,2,4\}$, then we go through, stopping at the shaded columns:

Then the total number of SAPs is given by the inclusion-exclusion formula

[TABLE]

For instance if $k=4$, then

[TABLE]

Note that when computing $N_{K}$, at each stage all but at most $k+1$ segments of the boundary of $A$ will lie in one of two columns that are $\alpha$ mod $k$ for $\alpha\in K$, so there are at most $2q+k+1$ edges crossing the boundary at any time and at most

[TABLE]

possibilities for those edge locations. Furthermore, because the path cannot self-intersect, the loops which connect edges crossing the boundary cannot cross each other, so they form a balanced set of parentheses, so the number of ways of connecting on the left is bounded by Catalan numbers. Using a power of 2 as an upper bound for Catalan numbers, there are at most $2^{2q+k+1}$ ways these edges can be connected inside $A$. Thus the number of states is bounded by

[TABLE]

Remembering that we need $O(n^{2})$ update steps for each $K$ and there are $2^{k}-1$ values of $K$ we need to deal with, we get that the runtime is

[TABLE]

and optimizing $k$ by setting it equal to $\sqrt{n\log n}$, we get a runtime of

[TABLE]

3 Better algorithm for more than two dimensions

We use a similar algorithm for $d\geq 3$ with some modifications. First, instead of merely choosing the set of good columns $K$, we choose a set of good hyperplanes in each direction. Second, when advancing, instead of going in chunks of at most $k$ columns, we go in chunks where each chunk is a rectangular prism each of whose sides is at most $k$. Thus the size of the part of the boundary of $A$ not lying in good hyperplanes is at most $dk^{d-1}$, so we can bound the number of edges in each state by $s=2dn/k+dk^{d-1}$. Finally, we can no longer use non-self-intersection to limit how edges can be connected within $A$, so we get a factor corresponding to the number of matchings of $s$ elements, which is $(s-1)!!\approx 2^{Cs\log s}$ instead of $2^{s}$. We now optimize $k=n^{1/d}$ and get a runtime of

[TABLE]

Note that we are getting $\log n$ here instead of $\sqrt{\log n}$ as in the $d=2$ case because we are counting all possible matchings on $s$ elements. However, many of these will require more than $n$ edges to implement. Thus, if we prune as we go, keeping only those states that can potentially arise as part of a SAP, we will get far fewer states, potentially replacing the $\log n$ with $\log n^{\sigma}$ for some $\sigma<1$.

4 Optimization considerations

It is unlikely that the algorithm for $d=3$ will be faster than the naive algorithm for any $n$ for which the computation is currently feasible, since for those values of $n$, we have $n^{2/3}\log n>n$ and the algorithm presented here has a large polynomial factor in front. For $d>3$ it is even worse. However, there is a chance that the $d=2$ algorithm on the square lattice can improve on the record of $n=79$ for SAWs set by Jensen in [9]. In this section we discuss some possible optimizations of the algorithm. First, one could speed the algorithm up by thinking of it as a modification of the algorithm given in that paper (and thus use all the optimizations used there, including pruning and keeping track of how things are connected on the right rather than the left). Additionally, by using that paper’s framework of counting the number of paths inscribed in a rectangle of width $W$ with length $L\geq W$, one can get better bounds than $n/k$ for $q$ (since we need to use at least $2W$ edges to cross the rectangle from bottom to top and left to right). We can perhaps eke out a further improvement by keeping track of the number $B$ of vertical edges. If $B$ is close to $W$, we only have a few spare vertical edges to use as vertical edges crossing the boundary or to connect horizontal edges, which severely restricts the number of states $S$, so we will have large gains from pruning. If the $B$ is significantly larger than $W$, we are tying up $B+W$ edges in order to be inscribed in the rectangle, so we can use a smaller value of $q$. One can choose different values of $k$ and $q$ for different values of $B$ (or for ranges of values of $B$, to have to run the algorithm fewer times). It is not clear how to make these choices optimally. It is also not clear if these optimizations are enough to improve on the record of $n=79$.

5 Acknowledgments

The author would like to thank the anonymous referees for copious useful comments. This material is based upon work supported by the National Science Foundation Graduate Research Fellowship Program under Grant No. DGE-1656466. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author and do not necessarily reflect the views of the National Science Foundation.