Jerrum's filter

Problems that use the Jerrum's filter
In any problem that reduces to the small generating set-finding problem, we can use Jerrum's filter. For instance:


 * In the order-finding problem, we need to repeatedly pass from a generating set of the bigger group to the smaller group. Jerrum's filter can be applied here to cut the size of the generating set after every occasion where we pass from the bigger group to the smaller group.

Other algorithms for the same problem
An alternative algorithm that can be used in place of Jerrum's filter is the Sims filter. The Sims filter outputs, in general, a much larger generating set, but the advantage of this filter is that it takes far less time.

In the Schreier-Sims algorithm, for instance, we use the Sims filter.

Broad idea
Recall that usually, when a group $$G$$ with generating set $$A$$ acts on a set $$S$$, we construct a graph where two vertices in $$S$$ (the cardinality $$n$$ set on which $$G$$ acts) are joined by a directed edge if there is an element in $$A$$ that takes one to the other. This graph has a lot of edges, in particular, it has $$n$$ edges for each element of $$A$$ (some of these edges may be loops).

The graph that we look at in Jerrum's filter has only one edge for each element of $$A$$, namely the edge from the least point moved by that element.

The idea is to keep transforming the generating set (which automatically keeps transforming the graph) till we attain an acyclic graph. The number of edges in this graph is at most $$n-1$$, and hence, once the graph has been made acyclic, the generating set has also been made small.

Outer loop of algorithm
Let $$A$$ be a generating set of the group $$G$$. The target of Jerrum's filter is to, starting from $$A$$, construct a small generating set from $$G$$.

Jerrum's filter uses an online algorithm. The algorithm reads in an element of $$A$$ at a time and keeps constructing a generating set that always generates the same subgroup as the part of $$A$$ read so far, and that is always small in size.

The processing within each step
Suppose $$A_0$$ is the part of $$a$$ that had been read in the past, $$a$$ is the new element, and $$A_1 = A_0 \cup \{a \}$$. Denote the size of $$B$$ at the beginning of the step by $$s$$.

Below is the fix the cycle inner loop. Note that this loop is initiated only in case we did actually change $$B$$ to $$B \cup \{ a \}$$. The loop steps are denoted IL1, IL2, etc. to avoid confusion with the numbering above:

Note that there are two ways that the fix the cycle loop could terminate. The first is that we reach a stage where we enter the "$$h$$ is the identity element case" and this we exit the loop with the size of $$B$$ equal to $$s$$, i.e., the reading in of $$A$$ did not in fact increase the size of $$B$$. The other case is that we reach a stage that the graph becomes acyclic at the end of the inner loop iteration. In this case, the size of $$B$$ is $$s + 1$$, i.e., the reading in of $$a$$ did increment the size.

Note also that if $$B$$ already has size $$n - 1$$, the loop must terminate through the identity element case since there is no scope for the size to increase.

We now show that the do-while loop terminates in finitely many iterations.

Weight argument
Define the weight of a permutation as the smallest element moved by it, and define the weight of a set of permutations as the sum of the weights of individual permutations in that set. We show that the process must terminate in finitely many steps. In fact, the number of steps is at most $$n(s + 1)$$, which is $$O(n^2)$$, because $$s + 1 \le n$$. The argument is below:

Analysis of running time
The run-time bounds column in the algorithm show that the total run time for reading each element is $$O(n^4)$$. The bottleneck step is the fix the cycle inner loop, which could iterate $$O(n^2)$$ times and within which each iteration takes $$O(n^2)$$ time. Within each iteration of the loop, the bottleneck step is the computation of a product of permutations corresponding to a cycle in $$X$$.

The total running time is $$O(|A|n^4)$$.

If $$|A|$$ is much smaller than $$n$$, then the step sizes can be bounded better in terms of $$|A|$$. However, in this case, Jerrum's filter may not be useful as it may not actually reduce the size of the generating set.