A game with $n$ players - II

To flesh out my comment a bit: you can extend your calculations out further without much difficulty, at least to $n=10$ or $n=12$ish. Iterate over all $n!$ permutations of $1..n$, and for each permutation $\rho=p_1p_2p_3\ldots p_n$ (note that this is 'mapping' notation, not cycle notation) you can compute the probability that each number is the winner by maintaing a list of the probabilities $x_1, \ldots, x_n$ that each element is the winner of the tournament (for the current permutation): initialize with $x_{p_1}=1$, and then at step $i$ (for $i=2\ldots n$), set $x_{p_j}=x_{p_j}\times\dfrac{p_j}{p_j+p_i}$ for all $j\lt i$, and set $x_{p_i}=1-\sum_{j\lt i}x_{p_j}$. Finally, just accumulate over all permutations.

For each subset $S\subseteq \{1,2,\ldots, n\}$, you can calculate the probability that each $i\in S$ is the winner of a random tournament of $S$. You will do this recursively. For singleton subsets, clearly the sole player is the winner. (Hooray!) For a set of size $m > 1$, iterate over the $m$ players, considering each in turn to be the last player (which will happen with probability $1/m$). In each case, the first $m-1$ players play a random tournament, which has $m-1$ possible winners whose probabilities we already computed and cached; and in each of these cases, either the last player ($i$) or the winner-so-far ($j$) is the final winner, with probabilities $i/(i+j)$ and $j/(i+j)$. So you're iterating over only $m(m-1)$ cases to get the random-tournament-winner probabilities for a particular set of size $m$, once you've done it for sets of size $m-1$. At worst it's taking $n(n-1)2^n$ steps to get the random-tournament probabilities for $\{1,2,\ldots, n\}$. This is very efficient; the Python code below runs for $n=20$ in less than a minute.

def winners(S, cache={}):
  # S will be a sorted tuple
  if cache.has_key(S): return cache[S]
  m = len(S)
  ret = {}
  for ix in xrange(m):
    i = S[ix]
    T = S[:ix] + S[(ix+1):]
    if not T:
      ret[i] = 1.0
    else:
      for (j, pj) in winners(T, cache).items():
        ret[i] = ret.get(i, 0.0) + (1.0 * pj * i) / (m * (i+j))
        ret[j] = ret.get(j, 0.0) + (1.0 * pj * j) / (m * (i+j))
  cache[S] = ret
  return ret

The results are interesting. Not only is the hypothesis true, at least that far out, but the inequality also becomes tight: the probability that $i$ wins appears to converge uniformly to $2i / (n(n+1))$ with increasing $n$. By $n=20$, each probability is within about $6\%$ of this.