Counterexamples to conjectures about Subset Takeaway and counting linear extensions of a Boolean lattice

TL;DR

This paper introduces an efficient recursive algorithm for posets, demonstrating its utility by disproving conjectures about the Subset Takeaway game and calculating linear extensions of Boolean lattices.

Contribution

The paper presents a novel recursive algorithm for poset functions, enabling the disproof of existing conjectures and precise enumeration of linear extensions in complex lattices.

Findings

Disproved conjectures about Subset Takeaway game.

Successfully computed linear extensions of a 7-cube lattice.

Demonstrated algorithm's efficiency in poset analysis.

Abstract

We develop an algorithm for efficiently computing recursively defined functions on posets. We illustrate this algorithm by disproving conjectures about the game Subset Takeaway (Chomp on a hypercube) and computing the number of linear extensions of the lattice of a 7-cube and related lattices.

Tables

$n\backslash k$	0	1	2	3	4	5	6	7	8
0	0
1	0	1
2	0	0	2
3	0	1	0	3
4	0	0	1	0	1
5	0	1	2	1	0	2
6	0	0	0	2	2	0	3
7	0	1	1	0	3	1	5	6
8	0	0	2

$g$	antichain
9	01, 02, 03, 04, 05, 06, 12, 13, 14, 15, 23, 24, 35, 46
23	012, 013, 014, 015, 023, 024, 025, 026, 034, 045,
	056, 123, 126, 135, 136, 145, 236, 245, 346, 456
37	0124, 0134, 0234, 1234, 0125, 0235, 1235, 0145, 0245, 1245,
	0345, 2345, 0126, 0136, 0236, 1236, 0146, 0246, 1246, 0156, 1356
44	012345, 01236, 01246, 01346, 2346, 01256, 1356, 2356, 0456

$n$	$e\left(B_n\right)$
0	1
1	1
2	2
3	48
4	1680384
5	14807804035657359360
6	141377911697227887117195970316200795630205476957716480
7	630470261306055898099742878692134361829979979674711225065761605059425-
	237453564989302659882866111738567871048772795838071474370002961694720

poset	computation	time	posets
		(minutes)	stored
$P_{7,3}$	win/loss	5	9680539
$P_{7,7}$	win/loss	230	401448670
$P_{7,3}$	Grundy	22	15466911
$P_{7,7}$	Grundy	637	490013147
$P_{7,3}$	linear extensions	5	15466911
$P_{7,7}$	linear extensions	148	490013147

Equations

$$e(P)=\begin{cases}1,&\mbox{if $P=\emptyset$,}\\[5.0pt] \displaystyle\sum_{m}\,e(P\setminus\{m\}),&\mbox{otherwise,}\end{cases}$$

$$e(P_{n,2})=\frac{n!\left(\left(\genfrac{}{}{0ex}{}{n}{2}\right)+n\right)!}{\prod _{i=1}^{n}in-\left(\genfrac{}{}{0ex}{}{i}{2}\right)}.$$

$$\sum _{r=0}^{i-1}n-r=in-\left(\genfrac{}{}{0ex}{}{i}{2}\right)$$

$$e(P_{n,2})=\frac{n!\left(\left(\genfrac{}{}{0ex}{}{n}{2}\right)+n-2\right)!}{\prod _{i=1}^{n-2}in-\left(\genfrac{}{}{0ex}{}{i}{2}\right)}=\frac{n!\left(\left(\genfrac{}{}{0ex}{}{n}{2}\right)+n\right)!}{\prod _{i=1}^{n}in-\left(\genfrac{}{}{0ex}{}{i}{2}\right)}.\text{vspace}\ast -10pt$$

Full text

1. Introduction

In this note we solve two problems on small Boolean lattices. The first is that of finding the optimal strategy for the game of Chomp (or Subset Takeaway). The second is that of counting the number of linear extensions. In both cases the method is recursive descent on normalized posets.

Chomp is a game played on a partially ordered set $P$ with smallest element 0. A move consists of choosing a nonzero element $x$ of $P$ and removing $x$ and all larger elements from $P$. Whoever is unable to move loses. This game has been studied for several families of partially ordered sets. For some history and discussion, see the web page [3]. The name Chomp is due to Martin Gardner [7].

If $P$ has a largest element 1, different from 0, then a trivial strategy-stealing argument shows that the first player wins. (If choosing 1 does not win, it is because the opponent has the devastating reply $a$. But in that case the first player wins by starting with $a$.) However, this argument is non-constructive: the winning move is unknown.

Subset Takeaway is the special case of Chomp, where $P$ is chosen to be the Boolean lattice $B_{n}$ of all subsets of an $n$-set. It was studied by Gale and Neyman [6]. Since there is a largest element, the first player wins. But how? Gale and Neyman asked whether taking the top element, the unique $n$-set, is the winning move, and this is true for $n\leq 5$ ([6]) and for $n=6$ ([4]). More generally, let $P=P_{n,k}$ be the partially ordered set of all subsets of size at most $k$ from an $n$-set. Gale and Neyman asked whether the first player loses in $P_{n,k}$ if and only if $(k+1)\mid n$, and prove this for $k\leq 2$.

However, we show that these longstanding conjectures are false. Indeed, using computer search, one finds fairly easily that the first player loses in $P_{7,3}$ and with more effort that the first player wins in $P_{7,6}$ (by choosing any 4-set). In particular, the top move in $P_{7,7}$ is not a winning move, but a 4-set is.

In Section 2, we extend the above results by giving computations of Grundy values of $P_{n,k}$ for some values of $n$ and $k$, showing that a natural pattern fails to continue. We also list some positions with large Grundy values, and describe how a reduction technique using involutions can extend our results to some larger positions. In Section 3, we apply our methods to the problem of counting the number of linear extensions of the poset $B_{n}$. The asymptotic behaviour of this sequence of numbers is of interest, and bounds were given in [1, 10]. Our methods of computation are much more efficient than previous methods, allowing us to easily reproduce known results for $n\leq 6$ and to compute the answer for $n=7$ for the first time. In addition, we derive a formula for $e(P_{n,2})$, and give computations of $e(P_{n,3})$. Finally, in Section 4, we discuss the size of the search space, describe the techniques we used to efficiently search it, and give some sample running times and space requirements that could be useful for future work.

We thank Alejandro Morales for bringing to our attention the problem of counting linear extensions.

2. Subset Takeaway

2.1. Win/loss computation

We computed that the only winning move in $P_{7,7}$ is to choose a set of size 4. As we will explain below, the search tree is much too large to be analyzed by hand, but we can give the first two layers. A move of size 1 leads to $P_{6,6}$, in which the winning move is known to be the set of size 6. Symmetrically, the response to a set of size 6 is the complement. Similarly, the winning response to a move of size 2 or 5 is the complement; this follows from the symmetry exchanging the elements of the move of size 2, using the technique described in Subsection 2.4. However, the winning response to a move of size 3 is not the complement. For example, our programs show that a winning response to $\{0,1,2\}$ is $\{0,1,3,4,5\}$. The remaining case is a move of size 4, which our programs show is a winning move.

2.2. Grundy values

Any impartial game, such as Subset Takeaway, is equivalent in the sense of combinatorial game theory to the game of Nim (cf. [5]). Thus to each game position $P$ one can associate a nonnegative integer $g$ such that $P$ is equivalent to a Nim heap of size $g$. This $g$ is called the Grundy value of $P$, and is the smallest nonnegative integer that is not the Grundy value of one of the positions that can be reached by one move. The position is lost for the first player if and only if the Grundy value is 0. We give the Grundy values of $P_{n,k}$ for $0\leq k\leq n$ in small cases.

In [8], the Grundy values of complete multipartite graphs are determined. In particular, they show that the Grundy value of $P_{n,2}$ is $n$ modulo $3$, agreeing with the $k=2$ column of the table. Note that, without the results in bold, one might conjecture that the Grundy value of $P_{n,k}$ is $n$ modulo $k+1$. We believe that most of the results for $k>2$ are new, except for the zeros when $k=n-1$ and $n\leq 6$. Other values are unknown.

We have seen already that $P_{n,n}$ is a first player win for all $n>0$. We shall see below that $P_{8,3}$, $P_{8,5}$, and $P_{9,3}$ are first player wins (and hence have a positive Grundy value).

2.3. Large Grundy values

Some positions in these games have rather large Grundy values $g$. In the table below we give $g$ and the maximal sets of a simplicial complex with this Grundy value, for various positions with $n=7$. We write $ab$ instead of $\{a,b\}$, etc.

2.4. Involutions

Suppose $P$ is a poset and $\phi:P\to P$ an automorphism of order 2 such that $P_{0}=\{x\in P\mid\phi(x)=x\}$ is downwards closed. Then the games on $P$ and $P_{0}$ have the same outcome. (Indeed, if $P_{0}$ is a second player win, then the second player can answer each move $x$ outside $P_{0}$ with $\phi(x)$, and each move inside $P_{0}$ with the winning strategy for $P_{0}$. If $P_{0}$ is a 1st player win, with winning move $x_{0}$, then the 1st player can play $x_{0}$ and then apply the previous sentence.) More generally, $P$ and $P_{0}$ have the same Grundy value (cf. [8]).

It is easy to see that $P_{8,3}$ is a first player win: just pick a singleton, reducing to $P_{7,3}$ which is a first player loss. This involution argument allows one to see that $P_{8,5}$ is also a first player win: pick a 2-set, say $\{6,7\}$, and apply the transposition $(67)$ to reduce to $P_{6,5}$ which is a first player loss. More generally, we see that if $P_{n,k}$ is a first player loss, then $P_{n+1,k}$ is a first player win if $k>0$, and $P_{n+2,k}$ is a first player win if $k>1$. So, $P_{9,3}$ is also a first player win.

3. Counting linear extensions of a Boolean lattice

The machinery we developed for studying Subset Takeaway on an $n$-set can be used more generally to recursively compute a function whose value on a poset is defined in terms of its values on smaller posets. Another example of such a function is $e(P)$, the number of linear extensions of the poset $P$. A linear extension of a poset $P$ is a total order on $P$ which is compatible with the given partial order. We can compute the number of linear extensions of $P$ in the following way. The maximum element of a total order must be one of the maximal elements of $P$, so $e(P)$ is given by

[TABLE]

where the sum is over the maximal elements $m$ of $P$. The values of $e(P)$ when $P$ is the Boolean lattice $B_{n}$ of subsets of an $n$-set were known for $n\leq 6$ (see OEIS A046873 [11]). We also give the value for $n=7$ (roughly $6.3\cdot 10^{137}$).

630470261306055898099742878692134361829979979674711225065761605059425237453564989302659882866111738567871048772795838071474370002961694720

The value 70016 of $e(B_{4})/4!$ was given by Weinrich [12]. The value of $e(B_{5})$ was given by Morton [9], and $e(B_{6})$ was found by Wienand [14]. Wienand reports that the computation of $e(B_{6})$ took less than 16 hours on a compute server. For us that same computation took less than 1 second, while the computation of $e(B_{7})$ took less than 2.5 hours. Asymptotic bounds on $e(B_{n})$ were given in [1, 10]. In [2] it was shown that counting linear extensions is #P complete.

As a further test of our approach, one can derive the following explicit formula for $e(P_{n,2})$.

Proposition**.**

For $n\geq 0$,

[TABLE]

This formula gives 183516891399909333860213587968000000 as the value of $e(P_{8,2})$, which agrees with the results of our programs.

Proof.

The equation holds for $n=0,1$. Let $n\geq 2$. The factor of $n!$ in the numerator counts the orderings of the $n$ singletons. Assuming that they have been ordered $1<2<\cdots<n$, we count the possible placements of the $2$-sets. The $2$-set $\{n-1,\,n\}$ has one possible place. The $2$-set $\{n-2,\,n\}$ then has two possible places. This continues until the $2$-set $\{1,\,n\}$, which has $n-1$ possible places. The next $2$-set $\{n-2,\,n-1\}$ has $n+1$ places, the larger jump being because it can appear before or after $n$. The numbers increase by one until $\{1,\,n-1\}$, and then there is another jump by two for $\{n-3,\,n-2\}$. The process ends when we reach $\{1,\,2\}$, which has $\binom{n}{2}+n-2$ places. The result is a product of all $k$ between $1$ and $\binom{n}{2}+n-2$, except for those that are of the form

[TABLE]

for some $1\leq i\leq n-2$. Thus

[TABLE]

∎

Finding a formula for $e(P_{n,3})$ appears to be more difficult. Our computations of this for $n=3,4,5,6$ and $7$ give 48, 1680384, 37783650956544000, 567722883627880394131962569026437120 and 11468744734494754078263804379304906839548713527318697219614310400000.

4. Computation

4.1. Counting antichains

How much work is it to analyze $P_{n,n}$? The full game tree consists of all downwards closed families of sets on $n$ points, or, equivalently (by taking maximal elements), of all antichains on $n$ points. The number of antichains on $n$ points is known as the $n$-th Dedekind number $M(n)$, cf. OEIS A000372 [11]. A rough lower bound is found by taking arbitrary families of sets of size $\lfloor n/2\rfloor$, and we see that $\log_{2}M(n)\geq\binom{n}{\lfloor n/2\rfloor}$. For $0\leq n\leq 8$ the values of $M(n)$ are 2, 3, 6, 20, 168, 7581, 7828354, 2414682040998, 56130437228687557907788 (cf. [13]). Here both the empty antichain and the antichain consisting of just the empty set are counted.

The amount of work can be reduced by using the action of the symmetric group ${\rm Sym}(n)$ of order $n!$. This saves at most a factor of $n!$, and for $n=6,7$, and 8 the value of $M(n)/n!$ is approximately 10873, 479103580, and 1392123939203560464. The number of antichains on $n$ points up to isomorphism, or, equivalently, of unlabeled simplicial complexes with at most $n$ vertices, is given in OEIS A003182 [11]. For $0\leq n\leq 7$ the values are 2, 3, 5, 10, 30, 210, 16353, and 490013148. Note that our approximation $M(n)/n!$ gets better as $n$ increases, and so we expect something like $1.4\cdot 10^{18}$ antichains up to isomorphism for $n=8$.

We see that in order to answer questions about $P_{n,n}$ for $n=7$ it suffices to look at at most 490013148 posets, which is not too much for modern computers, while a brute force approach for $n=8$ requires looking at more than $10^{18}$ posets, which is infeasible today.

4.2. Methods

Both authors independently wrote and ran computer programs to verify the claims, and compared the programs on many test cases and against known positions.

As discussed above, one wants to use the action of ${\rm Sym}(n)$. This is done by bringing each downwards closed set into a canonical form and saving already computed values in a hash table. Given a downwards closed set $A$ on the set $N=\{0,\ldots,n-1\}$, we consider the invariant that assigns to each $i\in N$ the vector whose $j$th entry ($j=1,\ldots,n$) is the number of $j$-sets in $A$ containing $i$. We then apply a permutation to $N$ that brings these invariants into some lexmin order. Finally, we consider all permutations in ${\rm Sym}(n)$ that preserve the invariants and apply the one that puts $A$ in a lexmin form. Putting moves into canonical form is crucial for time and memory efficiency, and was also the bottleneck in our programs.

4.3. Sample running times and memory usage

The programs were written in C and were run on ordinary desktop hardware using a single core. Here we give sample computation times and posets stored. It would certainly be possible to improve these with more work, but they give an illustration of the resources we needed, which may help someone who wishes to reproduce or extend our work.

For all three types of computation, $P_{6,6}$ took less than 1 second and stored at most 16352 posets in the hash table. All of the computations required less than 32 GB of virtual memory, except for the last one, counting the number of linear extensions of $B_{7}$. It required 38 GB, but it would not be hard to reduce this by ordering the search by the number of elements of the posets.