Controlling distance of shuffling

Question

I have tried to ask this question before, but have never been able to word it correctly. I hope I have it right this time:

I have a list of unique elements. I want t

Answer 1

My idea is to generate permutations by moving at most d steps by generating d random permutations which move at most 1 step and chaining them together.

We can generate permutations which move at most 1 step quickly by the following recursive procedure: consider a permutation of {1,2,3,...,n}. The last item, n, can move either 0 or 1 place. If it moves 0 places, n is fixed, and we have reduced the problem to generating a permutation of {1,2,...,n-1} in which every item moves at most one place.

On the other hand, if n moves 1 place, it must occupy position n-1. Then n-1 must occupy position n (if any smaller number occupies position n, it will have moved by more than 1 place). In other words, we must have a swap of n and n-1, and after swapping we have reduced the problem to finding such a permutation of the remainder of the array {1,...,n-2}.

Such permutations can be constructed in O(n) time, clearly.

Those two choices should be selected with weighted probabilities. Since I don't know the weights (though I have a theory, see below) maybe the choice should be 50-50 ... but see below.

A more accurate estimate of the weights might be as follows: note that the number of such permutations follows a recursion that is the same as the Fibonacci sequence: f(n) = f(n-1) + f(n-2). We have f(1) = 1 and f(2) = 2 ({1,2} goes to {1,2} or {2,1}), so the numbers really are the Fibonacci numbers. So my guess for the probability of choosing n fixed vs. swapping n and n-1 would be f(n-1)/f(n) vs. f(n-2)/f(n). Since the ratio of consecutive Fibonacci numbers quickly approaches the Golden Ratio, a reasonable approximation to the probabilities is to leave n fixed 61% of the time and swap n and n-1 39% of the time.

To construct permutations where items move at most d places, we just repeat the process d times. The running time is O(nd).

Here is an outline of an algorithm.

arr = {1,2,...,n};
for (i = 0; i < d; i++) {
  j = n-1;
  while (j > 0) {
    u = random uniform in interval (0,1)
    if (u < 0.61) { // related to golden ratio phi; more decimals may help
      j -= 1;
    } else {
      swap items at positions j and j-1 of arr // 0-based indexing
      j -= 2;
    }
  }
}

Since each pass moves items at most 1 place from their start, d passes will move items at most d places. The only question is the uniform distribution of the permutations. It would probably be a long proof, if it's even true, so I suggest assembling empirical evidence for various n's and d's. Probably to prove the statement, we would have to switch from using the golden ratio approximation to f(n-1)/f(n-2) in place of 0.61.

There might even be some weird reason why some permutations might be missed by this procedure, but I'm pretty sure that doesn't happen. Just in case, though, it would be helpful to have a complete inventory of such permutations for some values of n and d to check the correctness of my proposed algorithm.

Update

I found an off-by-one error in my "pseudocode", and I corrected it. Then I implemented in Java to get a sense of the distribution. Code is below. The distribution is far from uniform, I think because there are many ways of getting restricted permutations with short max distances (move forward, move back vs. move back, move forward, for example) but few ways of getting long distances (move forward, move forward). I can't think of a way to fix the uniformity issue with this method.

import java.util.Random;
import java.util.Map;
import java.util.TreeMap;

class RestrictedPermutations {
  private static Random rng = new Random();

  public static void rPermute(Integer[] a, int d) {
    for (int i = 0; i < d; i++) {
      int j = a.length-1;
      while (j > 0) {
        double u = rng.nextDouble();
        if (u < 0.61) { // related to golden ratio phi; more decimals may help
          j -= 1;
        } else {
          int t = a[j];
          a[j] = a[j-1];
          a[j-1] = t;
          j -= 2;
        }
      }
    }
  }

  public static void main(String[] args) {
    int numTests = Integer.parseInt(args[0]);
    int d = 2;
    Map count = new TreeMap();
    for (int t = 0; t < numTests; t++) {
      Integer[] a = {1,2,3,4,5};
      rPermute(a,d);
      // convert a to String for storage in Map
      String s = "(";
      for (int i = 0; i < a.length-1; i++) {
        s += a[i] + ",";
      }
      s += a[a.length-1] + ")";
      int c = count.containsKey(s) ? count.get(s) : 0;
      count.put(s,c+1);
    }
    for (String k : count.keySet()) {
      System.out.println(k + ": " + count.get(k));
    }
  }

}