#!/usr/bin/env python3
"""Exhaustive 8x8 Cartan — ZERO FLOAT, integer arithmetic.
The Cartan matrix is block-diagonal (4 independent 2x2 blocks).
Each block [[273, w], [w, 273]] has integer eigenvalues {273+w, 273-w}.
No eigendecomposition needed — just 4 integer additions/subtractions per config."""
import time, json, math

def block_eigenvalues(m):
    """Eigenvalues of [[273, 256*m], [256*m, 273]] in INTEGER."""
    w = (256 * m)
    return (273 + w, 273 - w)

def all_partitions():
    strands = list(range(8)); result = []
    def backtrack(rem, cur):
        if not rem: result.append(tuple(sorted(tuple(sorted(p)) for p in cur))); return
        first = rem[0]; rest = rem[1:]
        for i, second in enumerate(rest): backtrack(rest[:i]+rest[i+1:], cur+[(first,second)])
    backtrack(strands, []); return sorted(set(result))

# Chiral modifiers as integer multiples: {1, 1/2, 3/2} × 256
# Use rational pairs (num, den) to keep everything integer
CHIRAL = {
    "A": (1, 1),    # achiral: m = 1
    "S": (1, 2),    # scarred: m = 1/2
    "L": (3, 2),    # left bias: m = 3/2
    "R": (3, 2),    # right bias: m = 3/2
}

NAMES = ["A", "S", "L", "R"]

def chiral_mask_name(mask):
    return "".join(NAMES[m] for m in mask)

def compute_lam(partition, mask):
    """Compute λ_min, λ_max as integers. No floats."""
    all_lo = []
    all_hi = []
    for (a, b) in partition:
        num_a, den_a = CHIRAL[NAMES[mask[a]]]
        num_b, den_b = CHIRAL[NAMES[mask[b]]]
        # m = (a.num/a.den + b.num/b.den) / 2
        # w = 256 * m = 128 * (a.num/a.den + b.num/b.den)
        # Use common denominator: w = 128 * (num_a*den_b + num_b*den_a) / (den_a * den_b)
        num = 128 * (num_a * den_b + num_b * den_a)
        den = den_a * den_b
        w = num // den  # integer division — exact for these cases
        if num % den != 0:  # shouldn't happen with our values
            w = round(num / den)
        all_lo.append(273 + w)
        all_hi.append(273 - w)
    return max(all_lo), min(all_hi)

t0 = time.time()
partitions = all_partitions()

# Since Cartan weights are UNIFORM, all 105 partitions give identical results.
# Just compute on first partition × all 4^8 chiral masks.
partition = partitions[0]
total = 4**8
lam_min_set, lam_max_set = set(), set()
canonical = 0; rossby = 0; counts = {}

print(f"Computing 4^8 = {total:,} chiral configurations (integer only)...")
for mask_int in range(total):
    mask = [(mask_int // (4**i)) % 4 for i in range(8)]
    lam_max, lam_min = compute_lam(partition, mask)
    lam_min_set.add(lam_min)
    lam_max_set.add(lam_max)
    if lam_min == 17: canonical += 1
    if lam_min < 0: rossby += 1
    key = (lam_min, lam_max)
    counts[key] = counts.get(key, 0) + 1

t1 = time.time()

print(f"\nDone in {t1-t0:.1f}s")
print(f"Integer arithmetic only — zero floats.")
print(f"\nResults for 4^8 = {total:,} configurations:")
print(f"  Canonical (λ_min=17): {canonical} ({canonical/total*100:.1f}%)")
print(f"  Rossby-active (λ_min<0): {rossby} ({rossby/total*100:.1f}%)")
print(f"\nDistinct spectral states:")
print(f"  λ_min values: {sorted(lam_min_set)}")
print(f"  λ_max values: {sorted(lam_max_set)}")
print(f"  Total distinct states: {len(counts)}")
print(f"\nSpectral state distribution:")
for (lo, hi), n in sorted(counts.items(), key=lambda x: -x[1])[:10]:
    print(f"  λ=[{lo:>4}, {hi:>4}] -> {n:>5} configs ({n/total*100:5.1f}%)")

# All 105 partitions give the same results (uniform Cartan weights)
full_total = len(partitions) * total
print(f"\nAll 105 partitions × 4^8 = {full_total:,} configs:")
print(f"  Same results (uniform weights). 105 × {total:,} = {full_total:,}")
print(f"  Partition count is multiplicative — just scales the config count.")

receipt = {
    "schema": "exhaustive_8x8_v2", "zero_float": True,
    "partitions": len(partitions), "chiral_configs": total,
    "total": full_total, "compute_time_s": round(t1-t0, 2),
    "canonical": canonical, "rossby": rossby,
    "lambda_min_values": sorted(lam_min_set),
    "lambda_max_values": sorted(lam_max_set),
    "distinct_states": len(counts),
    "note": "All integer arithmetic. Block eigenvalues = 273 ± w where w = 256*m, m = chiral average."
}
with open("signatures/exhaustive_8x8_receipt.json", "w") as f:
    json.dump(receipt, f, indent=2)
print(f"\nReceipt: signatures/exhaustive_8x8_receipt.json")