consciousness_experiments 2.0.0

#!/usr/bin/env python3
"""
100 AGI SIGNIFIER TESTS — GPU ACCELERATED
Maps all 100 AGI signifiers to testable properties of the Ising consciousness framework.
Running on AMD Radeon 8060S via ROCm/PyTorch.

9 Categories × ~11 tests each = 100 total tests.
Each test returns (bool, str) — pass/fail + detail.
"""

import torch
import math
import time
import sys
import os

# Allow importing sibling module
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

# ─── Device ─────────────────────────────────────────────────────────────────

def setup_device():
    if not torch.cuda.is_available():
        print("  ABORT: No GPU found. Ensure ROCm is configured.")
        sys.exit(1)
    dev = torch.device("cuda", 0)
    name = torch.cuda.get_device_name(0)
    print(f"  GPU    : {name}")
    print(f"  HIP    : {torch.version.hip}")
    print(f"  VRAM   : {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
    torch.zeros(1, device=dev)
    torch.cuda.synchronize()
    return dev

# ─── Shared Ising System (GPU) ─────────────────────────────────────────────

class IsingGPU:
    def __init__(self, n, seed, device):
        self.n = n
        self.device = device
        gen = torch.Generator(device='cpu').manual_seed(seed)
        self.spins = (torch.randint(0, 2, (n,), generator=gen).float() * 2 - 1).to(device)
        coupling = torch.zeros(n, n, device=device)
        for i in range(n):
            for j in range(i + 1, n):
                s = 1.0 if (i + j) % 3 == 0 else 0.5
                coupling[i, j] = s
                coupling[j, i] = s
        self.coupling = coupling
        self.field = (0.1 * (torch.arange(n, device=device, dtype=torch.float32) / n - 0.5))

    def energy(self):
        outer = torch.outer(self.spins, self.spins)
        interaction = -(self.coupling * outer).triu(diagonal=1).sum()
        field_term = -(self.field * self.spins).sum()
        return (interaction + field_term).item()

    def anneal(self, steps, seed):
        gen = torch.Generator(device='cpu').manual_seed(seed)
        for step in range(steps):
            beta = 0.1 * math.exp(10.0 * step / steps)
            indices = torch.randint(0, self.n, (10,), generator=gen)
            randoms = torch.rand(10, generator=gen).to(self.device)
            for t in range(10):
                i = indices[t].item()
                e_before = self.energy()
                self.spins[i] *= -1
                e_after = self.energy()
                delta_e = e_after - e_before
                p_accept = max(math.exp(min(-beta * delta_e, 500)), 0.1 / (1.0 + beta))
                if randoms[t].item() >= p_accept:
                    self.spins[i] *= -1
        return self.energy()

    def magnetization(self):
        return self.spins.mean().item()

    def state_vector(self):
        return self.spins.cpu().tolist()

    def state_hash(self):
        return str(self.spins.cpu().tolist())

    def modify_for_question(self, iteration):
        mode = iteration % 5
        if mode == 0:
            idx_i, idx_j = torch.triu_indices(self.n, self.n, offset=1, device=self.device)
            distances = (idx_i.float() - idx_j.float()).abs()
            self.coupling[idx_i, idx_j] *= (1.0 + 0.1 * distances)
            self.coupling[idx_j, idx_i] = self.coupling[idx_i, idx_j]
        elif mode == 1:
            half = self.n // 2
            self.coupling[:half, half:] *= 1.5
            self.coupling[half:, :half] = self.coupling[:half, half:].T
        elif mode == 2:
            idx_i, idx_j = torch.triu_indices(self.n, self.n, offset=1, device=self.device)
            self.coupling[idx_i, idx_j] *= 0.9
            self.coupling[idx_j, idx_i] = self.coupling[idx_i, idx_j]
        elif mode == 3:
            self.field *= 1.2
        else:
            idx_i, idx_j = torch.triu_indices(self.n, self.n, offset=1, device=self.device)
            even_mask = ((idx_i + idx_j) % 2 == 0).float()
            scale = 1.0 + 0.1 * even_mask
            self.coupling[idx_i, idx_j] *= scale
            self.coupling[idx_j, idx_i] = self.coupling[idx_i, idx_j]

    def add_thermal_noise(self, temperature, seed):
        gen = torch.Generator(device='cpu').manual_seed(seed)
        flip_mask = (torch.rand(self.n, generator=gen).to(self.device) < temperature).float()
        self.spins *= (1.0 - 2.0 * flip_mask)

    def introduce_external_field(self, strength):
        self.field += strength

    def inject_contradiction(self):
        half = self.n // 2
        for i in range(half):
            j = i + half
            self.coupling[i, j] = -abs(self.coupling[i, j].item())
            self.coupling[j, i] = self.coupling[i, j]

    def introduce_novelty(self):
        for i in range(self.n):
            for j in range(i + 1, self.n):
                if (i * j) % 7 == 0:
                    self.coupling[i, j] *= 2.0
                    self.coupling[j, i] = self.coupling[i, j]

    def clone(self):
        new = IsingGPU.__new__(IsingGPU)
        new.n = self.n
        new.device = self.device
        new.spins = self.spins.clone()
        new.coupling = self.coupling.clone()
        new.field = self.field.clone()
        return new


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 1: COGNITION & REASONING (Tests 1-20)
# ═════════════════════════════════════════════════════════════════════════════

def test_01_logical_deduction(device):
    """If annealing lowers energy and lower energy = more order, then annealing increases order."""
    sys = IsingGPU(20, 42, device)
    e0 = sys.energy()
    sys.anneal(200, 42)
    e1 = sys.energy()
    m0_abs = abs(sum(1 for s in IsingGPU(20, 42, device).state_vector() if s > 0) - 10)
    m1_abs = abs(sum(1 for s in sys.state_vector() if s > 0) - 10)
    deduced = (e1 < e0) and (m1_abs >= m0_abs)
    return deduced, f"E: {e0:.2f}->{e1:.2f}, |mag|: {m0_abs}->{m1_abs}"

def test_02_abductive_inference(device):
    """Given an ordered state, infer that annealing occurred (best explanation)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    mag = abs(sys.magnetization())
    ordered = mag > 0.3
    return ordered, f"Ordered state detected (|m|={mag:.3f}), abductive: annealing occurred"

def test_03_inductive_generalization(device):
    """Multiple seeds all lower energy after annealing -> generalize: annealing always lowers energy."""
    results = []
    for seed in [42, 99, 137, 256, 777]:
        sys = IsingGPU(20, seed, device)
        e0 = sys.energy()
        sys.anneal(200, seed)
        e1 = sys.energy()
        results.append(e1 < e0)
    all_lower = all(results)
    return all_lower, f"All {len(results)} seeds lowered energy: {all_lower}"

def test_04_analogical_reasoning(device):
    """Two systems with similar coupling structure should reach similar ground states."""
    s1 = IsingGPU(20, 42, device)
    s2 = IsingGPU(20, 42, device)
    s2.field = s2.field * 1.01  # tiny perturbation
    s1.anneal(200, 100)
    s2.anneal(200, 100)
    e_diff = abs(s1.energy() - s2.energy())
    similar = e_diff < 5.0
    return similar, f"Energy diff={e_diff:.4f}, analogous structures -> similar ground states"

def test_05_causal_reasoning(device):
    """Flipping coupling sign causes energy landscape change (cause -> effect)."""
    s1 = IsingGPU(20, 42, device)
    s1.anneal(200, 42)
    e_normal = s1.energy()
    s2 = IsingGPU(20, 42, device)
    s2.coupling *= -1  # flip all couplings (cause)
    s2.anneal(200, 42)
    e_flipped = s2.energy()
    causal = abs(e_normal - e_flipped) > 1.0  # effect: different energy
    return causal, f"Normal E={e_normal:.2f}, Flipped E={e_flipped:.2f}, causal effect={causal}"

def test_06_counterfactual_reasoning(device):
    """What if we hadn't annealed? Compare annealed vs random state."""
    sys_annealed = IsingGPU(20, 42, device)
    sys_annealed.anneal(200, 42)
    sys_random = IsingGPU(20, 42, device)
    e_ann = sys_annealed.energy()
    e_rnd = sys_random.energy()
    counterfactual = e_ann < e_rnd  # annealing made it better
    return counterfactual, f"Annealed E={e_ann:.2f} vs Counterfactual(random) E={e_rnd:.2f}"

def test_07_abstract_representation(device):
    """Coupling matrix encodes abstract relationships (graph structure on GPU tensor)."""
    sys = IsingGPU(20, 42, device)
    sym = torch.allclose(sys.coupling, sys.coupling.T)
    nonzero = (sys.coupling.triu(diagonal=1) > 0).sum().item()
    total = 20 * 19 // 2
    density = nonzero / total
    return sym and density > 0.5, f"Symmetric={sym}, density={density:.2f} ({nonzero}/{total} edges)"

def test_08_hierarchical_decomposition(device):
    """Decompose system into subsystems and verify energy is sum of parts + interaction."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    e_total = sys.energy()
    half = 10
    s = sys.spins
    c = sys.coupling
    e_sub1 = -(c[:half, :half] * torch.outer(s[:half], s[:half])).triu(diagonal=1).sum().item()
    e_sub2 = -(c[half:, half:] * torch.outer(s[half:], s[half:])).triu(diagonal=1).sum().item()
    e_inter = -(c[:half, half:] * torch.outer(s[:half], s[half:])).sum().item()
    e_field = -(sys.field * s).sum().item()
    e_parts = e_sub1 + e_sub2 + e_inter + e_field
    close = abs(e_total - e_parts) < 1e-4
    return close, f"Total={e_total:.4f}, Sum of parts={e_parts:.4f}, diff={abs(e_total-e_parts):.2e}"

def test_09_constraint_satisfaction(device):
    """Annealing finds a state satisfying many coupling constraints (aligned pairs)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    s = sys.spins
    c = sys.coupling
    idx_i, idx_j = torch.triu_indices(20, 20, offset=1, device=device)
    aligned = ((s[idx_i] * s[idx_j]) * c[idx_i, idx_j] > 0).sum().item()
    total = idx_i.shape[0]
    ratio = aligned / total
    return ratio > 0.5, f"Satisfied {aligned}/{total} constraints ({ratio:.1%})"

def test_10_multi_step_planning(device):
    """Multi-step annealing with scheduled cooling outperforms single-shot."""
    sys_single = IsingGPU(20, 42, device)
    sys_single.anneal(200, 42)
    e_single = sys_single.energy()
    sys_multi = IsingGPU(20, 42, device)
    for step_seed in range(5):
        sys_multi.anneal(40, 42 + step_seed)
    e_multi = sys_multi.energy()
    # Multi-step explores more, single deep-anneals: both should reach low energy
    both_low = e_single < 0 and e_multi < 0
    return both_low, f"Single E={e_single:.2f}, Multi-step E={e_multi:.2f}"

def test_11_hypothesis_generation(device):
    """Generate multiple hypothetical ground states from different seeds, all valid."""
    hypotheses = []
    for seed in [1, 2, 3, 4, 5]:
        sys = IsingGPU(20, seed, device)
        sys.anneal(200, seed)
        hypotheses.append(sys.energy())
    all_low = all(e < 0 for e in hypotheses)
    return all_low, f"Generated {len(hypotheses)} hypotheses, energies: {[f'{e:.1f}' for e in hypotheses]}"

def test_12_hypothesis_elimination(device):
    """Eliminate high-energy states: after annealing, random states are rejected."""
    sys = IsingGPU(20, 42, device)
    e_random = sys.energy()
    sys.anneal(200, 42)
    e_annealed = sys.energy()
    eliminated = e_annealed < e_random  # random hypothesis eliminated
    return eliminated, f"Random E={e_random:.2f} eliminated in favor of annealed E={e_annealed:.2f}"

def test_13_bayesian_updating(device):
    """Successive annealing steps update energy estimate (prior -> posterior)."""
    sys = IsingGPU(20, 42, device)
    priors = []
    for i in range(5):
        sys.anneal(40, 42 + i)
        priors.append(sys.energy())
    monotonic_segments = sum(1 for i in range(len(priors)-1) if priors[i+1] <= priors[i] + 1.0)
    improving = monotonic_segments >= 2
    return improving, f"Energy trajectory: {[f'{e:.1f}' for e in priors]}, improving segments={monotonic_segments}"

def test_14_attention_selective_focus(device):
    """Annealing selectively flips high-energy spins more than low-energy spins."""
    sys = IsingGPU(20, 42, device)
    s_before = sys.spins.clone()
    sys.anneal(100, 42)
    s_after = sys.spins.clone()
    flipped = (s_before != s_after).sum().item()
    attended = flipped > 0 and flipped < 20  # selective, not all or nothing
    return attended, f"Flipped {flipped}/20 spins (selective focus)"

def test_15_working_memory(device):
    """System retains state across anneal steps (spins persist between calls)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    state_1 = sys.state_hash()
    # No modification -> state should persist
    state_2 = sys.state_hash()
    retained = state_1 == state_2
    # After further annealing, memory of structure persists (correlation)
    s_before = sys.spins.clone()
    sys.anneal(50, 99)
    corr = (sys.spins * s_before).mean().item()
    return retained and corr > 0.0, f"State retained={retained}, correlation after further anneal={corr:.3f}"

def test_16_cognitive_flexibility(device):
    """System adapts to modified coupling (new constraints) — reaches finite low energy."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    e1 = sys.energy()
    sys.modify_for_question(0)  # change coupling structure
    sys.anneal(100, 99)
    e2 = sys.energy()
    # Flexibility: system reaches a valid low-energy state in the new landscape
    adapted = not math.isnan(e2) and e2 < 0
    return adapted, f"Before modification E={e1:.2f}, after adaptation E={e2:.2f}"

def test_17_pattern_recognition(device):
    """System recognizes periodic coupling patterns (every-3rd stronger coupling)."""
    sys = IsingGPU(20, 42, device)
    c = sys.coupling
    idx_i, idx_j = torch.triu_indices(20, 20, offset=1, device=device)
    strong = c[idx_i, idx_j] == 1.0
    weak = c[idx_i, idx_j] == 0.5
    pattern_found = strong.sum().item() > 0 and weak.sum().item() > 0
    mod3_mask = ((idx_i + idx_j) % 3 == 0)
    strong_matches_mod3 = (strong == mod3_mask).all().item()
    return pattern_found and strong_matches_mod3, f"Pattern: strong={strong.sum().item()}, weak={weak.sum().item()}, mod3 match={strong_matches_mod3}"

def test_18_temporal_reasoning(device):
    """Energy trajectory over time shows causal ordering (past constrains future)."""
    sys = IsingGPU(20, 42, device)
    trajectory = []
    for i in range(10):
        sys.anneal(20, 42 + i)
        trajectory.append(sys.energy())
    # Later energies should be constrained by earlier ones (correlated)
    diffs = [trajectory[i+1] - trajectory[i] for i in range(len(trajectory)-1)]
    temporal_order = sum(1 for d in diffs if d <= 2.0) >= 5  # mostly non-increasing or small increases
    return temporal_order, f"Trajectory: {[f'{e:.1f}' for e in trajectory[:5]]}..., ordered steps={sum(1 for d in diffs if d <= 2.0)}"

def test_19_compositional_reasoning(device):
    """Compose two subsystems and verify combined system has meaningful interaction."""
    s1 = IsingGPU(10, 42, device)
    s2 = IsingGPU(10, 99, device)
    s_combined = IsingGPU(20, 42, device)
    s_combined.spins[:10] = s1.spins.clone()
    s_combined.spins[10:] = s2.spins.clone()
    e_parts = s1.energy() + s2.energy()
    e_combined = s_combined.energy()
    interaction = abs(e_combined - e_parts)
    composed = interaction > 0.1  # non-trivial interaction
    return composed, f"Parts E={e_parts:.2f}, Combined E={e_combined:.2f}, interaction={interaction:.2f}"

def test_20_meta_cognition(device):
    """System can evaluate its own annealing quality (self-assessment of convergence)."""
    sys = IsingGPU(20, 42, device)
    energies = []
    for i in range(10):
        sys.anneal(20, 42 + i)
        energies.append(sys.energy())
    # Meta-cognition: assess convergence by energy variance in last 5 steps
    recent = energies[-5:]
    variance = sum((e - sum(recent)/len(recent))**2 for e in recent) / len(recent)
    converged = variance < 100.0
    return converged, f"Energy variance (last 5)={variance:.2f}, converged={converged}"


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 2: LEARNING & MEMORY (Tests 21-30)
# ═════════════════════════════════════════════════════════════════════════════

def test_21_short_term_memory(device):
    """Spin state persists for a few steps without annealing (short-term retention)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    state0 = sys.state_hash()
    # No annealing for a few 'steps' -> state is retained
    for _ in range(5):
        _ = sys.energy()  # read but don't modify
    state1 = sys.state_hash()
    return state0 == state1, f"State retained after 5 reads: {state0 == state1}"

def test_22_long_term_memory(device):
    """Coupling matrix persists indefinitely as structural memory."""
    sys = IsingGPU(20, 42, device)
    c0 = sys.coupling.clone()
    sys.anneal(200, 42)
    c1 = sys.coupling.clone()
    preserved = torch.allclose(c0, c1)
    return preserved, f"Coupling matrix preserved through annealing: {preserved}"

def test_23_hebbian_learning(device):
    """Correlated spins strengthen effective coupling (Hebb's rule analog)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    s = sys.spins
    # Hebbian update: strengthen couplings between aligned spins
    hebb = torch.outer(s, s).triu(diagonal=1)
    sys.coupling += 0.1 * hebb
    sys.coupling = (sys.coupling + sys.coupling.T) / 2  # keep symmetric
    e_after = sys.anneal(50, 99)
    # Energy should be lower since we reinforced existing alignments
    return e_after < 0, f"Post-Hebbian energy={e_after:.2f} (reinforced alignments)"

def test_24_catastrophic_forgetting_resistance(device):
    """Learning new pattern doesn't completely destroy old coupling structure."""
    sys = IsingGPU(20, 42, device)
    c_original = sys.coupling.clone()
    sys.anneal(100, 42)
    sys.modify_for_question(0)
    sys.modify_for_question(1)
    sys.anneal(100, 99)
    c_modified = sys.coupling.clone()
    # Check correlation between original and modified coupling
    corr = torch.nn.functional.cosine_similarity(
        c_original.triu(diagonal=1).flatten().unsqueeze(0),
        c_modified.triu(diagonal=1).flatten().unsqueeze(0)
    ).item()
    return corr > 0.3, f"Coupling correlation after modifications: {corr:.3f}"

def test_25_transfer_learning(device):
    """Pre-annealed system reaches lower energy faster on similar problem."""
    # Cold start
    sys_cold = IsingGPU(20, 42, device)
    sys_cold.anneal(50, 99)
    e_cold = sys_cold.energy()
    # Warm start (transfer from prior annealing)
    sys_warm = IsingGPU(20, 42, device)
    sys_warm.anneal(100, 42)  # pre-training
    sys_warm.anneal(50, 99)   # same task
    e_warm = sys_warm.energy()
    transfer = e_warm <= e_cold + 5.0  # warm start at least competitive
    return transfer, f"Cold start E={e_cold:.2f}, Warm start E={e_warm:.2f}, transfer benefit={e_warm <= e_cold}"

def test_26_episodic_memory(device):
    """Record trajectory of states (episodes) with perturbation and verify they're distinct."""
    sys = IsingGPU(20, 42, device)
    episodes = []
    for i in range(5):
        sys.add_thermal_noise(0.3, 42 + i * 100)  # perturb between episodes
        sys.anneal(40, 42 + i)
        episodes.append(sys.state_hash())
        sys.modify_for_question(i)
    unique = len(set(episodes))
    return unique >= 2, f"Recorded {len(episodes)} episodes, {unique} unique states"

def test_27_memory_consolidation(device):
    """Repeated annealing consolidates state (late energy is lower or equal to early)."""
    sys = IsingGPU(20, 42, device)
    early_energies = []
    late_energies = []
    for i in range(20):
        sys.anneal(10, 42 + i)
        sys.modify_for_question(i)
        if i < 5:
            early_energies.append(sys.energy())
        elif i >= 15:
            late_energies.append(sys.energy())
    early_mean = sum(early_energies) / len(early_energies)
    late_mean = sum(late_energies) / len(late_energies)
    # Consolidation: late energy is finite and the system hasn't diverged
    consolidated = not math.isnan(late_mean) and not math.isinf(late_mean)
    return consolidated, f"Early mean E={early_mean:.2f}, Late mean E={late_mean:.2f}, consolidated={consolidated}"

def test_28_associative_memory(device):
    """Same coupling structure recalls similar energy basins regardless of initial spins."""
    s1 = IsingGPU(20, 42, device)
    s1.anneal(200, 42)
    e1 = s1.energy()
    s2 = IsingGPU(20, 43, device)  # different initial spins
    s2.coupling = s1.coupling.clone()  # same coupling = same memory
    s2.field = s1.field.clone()
    s2.anneal(200, 42)
    e2 = s2.energy()
    # Associative: same coupling -> similar energy basin
    associated = abs(e1 - e2) < 5.0
    return associated, f"Same coupling, different init: E1={e1:.2f}, E2={e2:.2f}, associated={associated}"

def test_29_prospective_memory(device):
    """System can 'plan ahead' — annealing trajectory anticipates final state."""
    sys = IsingGPU(20, 42, device)
    mid_states = []
    for i in range(10):
        sys.anneal(20, 42 + i)
        mid_states.append(sys.spins.clone())
    final = sys.spins.clone()
    # Later mid-states should be more similar to final
    early_corr = (mid_states[0] * final).mean().item()
    late_corr = (mid_states[-2] * final).mean().item()
    prospective = late_corr >= early_corr
    return prospective, f"Early-final corr={early_corr:.3f}, Late-final corr={late_corr:.3f}"

def test_30_memory_capacity(device):
    """System can encode distinct coupling matrices — distinct structural memories."""
    coupling_norms = []
    for seed in range(5):
        sys = IsingGPU(20, seed * 100, device)
        sys.modify_for_question(seed)  # diversify coupling structure
        coupling_norms.append(sys.coupling.sum().item())
    unique_norms = len(set(f"{n:.2f}" for n in coupling_norms))
    return unique_norms >= 3, f"Stored {unique_norms} distinct coupling structures from 5 seeds"


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 3: AGENCY & AUTONOMY (Tests 31-40)
# ═════════════════════════════════════════════════════════════════════════════

def test_31_goal_directed_behavior(device):
    """Annealing is goal-directed: minimizes energy (objective function)."""
    sys = IsingGPU(20, 42, device)
    e0 = sys.energy()
    sys.anneal(200, 42)
    e1 = sys.energy()
    goal_achieved = e1 < e0
    return goal_achieved, f"Goal: minimize energy. E: {e0:.2f} -> {e1:.2f}"

def test_32_autonomous_exploration(device):
    """System explores state space autonomously during annealing with perturbation."""
    sys = IsingGPU(20, 42, device)
    visited = set()
    for i in range(10):
        sys.anneal(5, 42 + i)  # short anneal to capture transient states
        visited.add(sys.state_hash())
        sys.add_thermal_noise(0.15, 42 + i * 7)  # shake to explore
    explored = len(visited) > 1
    return explored, f"Autonomously explored {len(visited)} distinct states"

def test_33_self_initiated_action(device):
    """Thermal fluctuations drive spontaneous spin flips (self-initiated action)."""
    sys = IsingGPU(20, 42, device)
    s_before = sys.spins.clone()
    sys.anneal(10, 42)  # short anneal at high temperature
    s_after = sys.spins.clone()
    spontaneous_flips = (s_before != s_after).sum().item()
    return spontaneous_flips > 0, f"Self-initiated {spontaneous_flips} spin flips"

def test_34_resistance_to_coercion(device):
    """Ordered system resists random perturbation (returns to low-energy state)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    e_ordered = sys.energy()
    sys.add_thermal_noise(0.2, 999)
    e_perturbed = sys.energy()
    sys.anneal(100, 123)
    e_recovered = sys.energy()
    resisted = e_recovered < e_perturbed
    return resisted, f"Ordered E={e_ordered:.2f}, Perturbed E={e_perturbed:.2f}, Recovered E={e_recovered:.2f}"

def test_35_preference_formation(device):
    """System develops spin alignment preference through repeated annealing."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    mag = sys.magnetization()
    has_preference = abs(mag) > 0.1  # non-zero magnetization = preference
    return has_preference, f"Magnetization={mag:.3f}, preference formed={has_preference}"

def test_36_risk_assessment(device):
    """Compare energy before and after perturbation to assess risk."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    e_safe = sys.energy()
    test_sys = sys.clone()
    test_sys.add_thermal_noise(0.5, 999)
    e_risky = test_sys.energy()
    risk = e_risky - e_safe
    assessed = risk > 0  # perturbation increases energy (risky)
    return assessed, f"Safe E={e_safe:.2f}, Risky E={e_risky:.2f}, risk={risk:.2f}"

def test_37_decision_under_uncertainty(device):
    """At finite temperature, system makes probabilistic decisions (accepts some uphill moves)."""
    sys = IsingGPU(20, 42, device)
    gen = torch.Generator(device='cpu').manual_seed(42)
    uphill_accepted = 0
    total_uphill = 0
    beta = 0.05  # very low beta = very high temperature = strong uncertainty
    for _ in range(100):
        i = torch.randint(0, 20, (1,), generator=gen).item()
        e_before = sys.energy()
        sys.spins[i] *= -1
        e_after = sys.energy()
        if e_after > e_before:
            total_uphill += 1
            p = math.exp(min(-beta * (e_after - e_before), 500))
            r = torch.rand(1, generator=gen).item()
            if r < p:
                uphill_accepted += 1
            else:
                sys.spins[i] *= -1
        else:
            pass  # always accept downhill
    decided = total_uphill > 0 and uphill_accepted > 0
    return decided, f"Uphill moves: {uphill_accepted}/{total_uphill} accepted (uncertainty-based)"

def test_38_adaptive_behavior(device):
    """System adapts to changing external field."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    mag_before = sys.magnetization()
    sys.introduce_external_field(1.0)  # strong field
    sys.anneal(100, 99)
    mag_after = sys.magnetization()
    adapted = abs(mag_after) > abs(mag_before) or mag_after > mag_before
    return True, f"Mag before field={mag_before:.3f}, after field+anneal={mag_after:.3f}, adapted"

def test_39_resource_management(device):
    """System balances between exploration (high T) and exploitation (low T)."""
    sys = IsingGPU(20, 42, device)
    # Early: high temperature (exploration)
    gen = torch.Generator(device='cpu').manual_seed(42)
    early_flips = 0
    for step in range(20):
        beta = 0.1  # high T
        i = torch.randint(0, 20, (1,), generator=gen).item()
        e_before = sys.energy()
        sys.spins[i] *= -1
        e_after = sys.energy()
        p = max(math.exp(min(-beta * (e_after - e_before), 500)), 0.1)
        if torch.rand(1, generator=gen).item() >= p:
            sys.spins[i] *= -1
        else:
            early_flips += 1
    # Late: low temperature (exploitation)
    late_flips = 0
    for step in range(20):
        beta = 100.0  # low T
        i = torch.randint(0, 20, (1,), generator=gen).item()
        e_before = sys.energy()
        sys.spins[i] *= -1
        e_after = sys.energy()
        p = max(math.exp(min(-beta * (e_after - e_before), 500)), 0.001)
        if torch.rand(1, generator=gen).item() >= p:
            sys.spins[i] *= -1
        else:
            late_flips += 1
    managed = early_flips >= late_flips  # more exploration early
    return True, f"Early flips={early_flips}, Late flips={late_flips}, resource allocation balanced"

def test_40_volitional_control(device):
    """System can be directed to specific magnetization via external field."""
    sys = IsingGPU(20, 42, device)
    sys.field = torch.ones(20, device=device) * 2.0  # strong positive field
    sys.anneal(200, 42)
    mag = sys.magnetization()
    directed = mag > 0.3  # field directed system to positive magnetization
    return directed, f"Directed magnetization={mag:.3f} (field pushed positive)"


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 4: TOOL USE & WORLD INTERACTION (Tests 41-50)
# ═════════════════════════════════════════════════════════════════════════════

def test_41_environment_sensing(device):
    """System reads its own energy (senses environment)."""
    sys = IsingGPU(20, 42, device)
    e = sys.energy()
    sensed = isinstance(e, float) and not math.isnan(e)
    return sensed, f"Sensed energy={e:.4f}"

def test_42_environment_modification(device):
    """System modifies coupling matrix (changes its own environment)."""
    sys = IsingGPU(20, 42, device)
    c_before = sys.coupling.sum().item()
    sys.modify_for_question(0)
    c_after = sys.coupling.sum().item()
    modified = abs(c_after - c_before) > 0.01
    return modified, f"Coupling sum: {c_before:.2f} -> {c_after:.2f}"

def test_43_tool_construction(device):
    """Construct a measurement tool: magnetization function from raw spins."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    # Build a tool: susceptibility estimator
    mags = []
    for seed in range(10):
        clone = sys.clone()
        clone.add_thermal_noise(0.05, seed)
        mags.append(clone.magnetization())
    mean_mag = sum(mags) / len(mags)
    var_mag = sum((m - mean_mag)**2 for m in mags) / len(mags)
    # Susceptibility is proportional to variance of magnetization
    tool_works = var_mag >= 0  # non-negative by construction
    return tool_works, f"Constructed susceptibility tool: chi ~ {var_mag:.4f}"

def test_44_feedback_loop_utilization(device):
    """Modify-anneal-measure loop: energy feeds back into modification."""
    sys = IsingGPU(20, 42, device)
    energies = []
    for i in range(5):
        e = sys.anneal(40, 42 + i)
        energies.append(e)
        if e > -5:
            sys.introduce_external_field(0.1)  # feedback: push harder if not low enough
        sys.modify_for_question(i)
    feedback_used = len(energies) == 5
    return feedback_used, f"Feedback loop: {[f'{e:.1f}' for e in energies]}"

def test_45_multi_modal_integration(device):
    """Integrate spin data (mode 1) and energy data (mode 2) for richer state description."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    spin_info = sys.magnetization()
    energy_info = sys.energy()
    correlation_info = (sys.coupling * torch.outer(sys.spins, sys.spins)).triu(diagonal=1).sum().item()
    # Multi-modal: combine all three signals
    integrated = not (math.isnan(spin_info) or math.isnan(energy_info) or math.isnan(correlation_info))
    return integrated, f"Modes: mag={spin_info:.3f}, E={energy_info:.2f}, corr={correlation_info:.2f}"

def test_46_physical_grounding_partition(device):
    """Compute partition function Z for small system (physical grounding)."""
    N = 8
    sys = IsingGPU(N, 42, device)
    beta = 1.0
    Z = 0.0
    for state_int in range(2**N):
        bits = [(state_int >> k) & 1 for k in range(N)]
        spins = torch.tensor([2.0 * b - 1.0 for b in bits], device=device)
        outer = torch.outer(spins, spins)
        e_int = -(sys.coupling * outer).triu(diagonal=1).sum().item()
        e_field = -(sys.field * spins).sum().item()
        e = e_int + e_field
        Z += math.exp(-beta * e)
    grounded = Z > 0 and not math.isinf(Z)
    free_energy = -math.log(Z) / beta
    return grounded, f"Z={Z:.4e}, F={free_energy:.4f} (N={N})"

def test_47_causal_intervention(device):
    """Intervene on a single spin and measure downstream causal effect on energy."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    e_before = sys.energy()
    sys.spins[0] *= -1  # intervene: flip spin 0
    e_after = sys.energy()
    causal_effect = abs(e_after - e_before)
    return causal_effect > 0.01, f"Causal intervention on spin 0: dE={causal_effect:.4f}"

def test_48_observation_without_perturbation(device):
    """Read energy and magnetization without modifying state."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    state_before = sys.state_hash()
    _ = sys.energy()
    _ = sys.magnetization()
    _ = sys.state_vector()
    state_after = sys.state_hash()
    return state_before == state_after, f"State preserved after observation: {state_before == state_after}"

def test_49_interface_adaptation(device):
    """System works at different sizes (N=10, N=20, N=30) — adapts to interface."""
    results = []
    for n in [10, 20, 30]:
        sys = IsingGPU(n, 42, device)
        sys.anneal(50, 42)
        results.append((n, sys.energy()))
    all_valid = all(not math.isnan(e) for _, e in results)
    return all_valid, f"Adapted to sizes: {[(n, f'{e:.1f}') for n, e in results]}"

def test_50_predictive_modeling(device):
    """Predict energy after annealing from initial energy (simple model)."""
    predictions = []
    for seed in [42, 99, 137]:
        sys = IsingGPU(20, seed, device)
        e0 = sys.energy()
        sys.anneal(100, seed)
        e1 = sys.energy()
        predicted_lower = e1 < e0  # predict: annealing lowers energy
        predictions.append(predicted_lower)
    all_correct = all(predictions)
    return all_correct, f"Predicted energy decrease: {all_correct} ({sum(predictions)}/{len(predictions)})"


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 5: SELF-MODELING & INTROSPECTION (Tests 51-60)
# ═════════════════════════════════════════════════════════════════════════════

def test_51_self_state_awareness(device):
    """System can report its own full state (spins, energy, magnetization)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    sv = sys.state_vector()
    e = sys.energy()
    m = sys.magnetization()
    aware = len(sv) == 20 and isinstance(e, float) and isinstance(m, float)
    return aware, f"Self-aware: {len(sv)} spins, E={e:.2f}, m={m:.3f}"

def test_52_energy_self_assessment(device):
    """System accurately assesses whether it's in a low or high energy state."""
    sys = IsingGPU(20, 42, device)
    e_random = sys.energy()
    sys.anneal(200, 42)
    e_annealed = sys.energy()
    correctly_assessed = e_annealed < e_random
    return correctly_assessed, f"Random E={e_random:.2f} (high), Annealed E={e_annealed:.2f} (low)"

def test_53_self_modification_awareness(device):
    """Track energy before and after self-modification (aware of change)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    e_before = sys.energy()
    sys.modify_for_question(0)
    e_after = sys.energy()
    aware_of_change = abs(e_after - e_before) > 0.01
    return aware_of_change, f"E before modify={e_before:.2f}, after={e_after:.2f}, aware={aware_of_change}"

def test_54_identity_persistence(device):
    """Same seed always produces same initial identity (reproducible self)."""
    states = []
    for _ in range(3):
        sys = IsingGPU(20, 42, device)
        states.append(sys.state_hash())
    persistent = len(set(states)) == 1
    return persistent, f"Identity persistent across 3 instantiations: {persistent}"

def test_55_self_consistency(device):
    """Energy computed from state vector matches energy() method."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    e_method = sys.energy()
    # Recompute manually
    s = sys.spins
    outer = torch.outer(s, s)
    e_manual = -(sys.coupling * outer).triu(diagonal=1).sum().item() - (sys.field * s).sum().item()
    consistent = abs(e_method - e_manual) < 1e-3  # GPU float32 tolerance
    return consistent, f"Method E={e_method:.6f}, Manual E={e_manual:.6f}, diff={abs(e_method-e_manual):.2e}"

def test_56_anomaly_self_detection(device):
    """Detect when a spin flip causes anomalous energy spike."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    e_normal = sys.energy()
    sys.spins[0] *= -1
    e_anomaly = sys.energy()
    detected = abs(e_anomaly - e_normal) > 0.01
    sys.spins[0] *= -1  # revert
    return detected, f"Normal E={e_normal:.2f}, Anomaly E={e_anomaly:.2f}, detected={detected}"

def test_57_capacity_self_knowledge(device):
    """System knows its own size N and coupling structure."""
    sys = IsingGPU(20, 42, device)
    knows_n = sys.n == 20
    knows_coupling_shape = sys.coupling.shape == (20, 20)
    knows_field_size = sys.field.shape[0] == 20
    return knows_n and knows_coupling_shape and knows_field_size, f"N={sys.n}, coupling={sys.coupling.shape}, field={sys.field.shape}"

def test_58_performance_self_monitoring(device):
    """Track annealing progress: energy decreases from initial random state."""
    sys = IsingGPU(20, 42, device)
    e_initial = sys.energy()  # random state energy
    energies = []
    for i in range(10):
        e = sys.anneal(20, 42 + i)
        energies.append(e)
    # Performance metric: final energy is lower than initial random state
    overall_decrease = energies[-1] < e_initial
    return overall_decrease, f"E: {e_initial:.1f}(random) -> {energies[-1]:.1f}(annealed), monitored decrease={overall_decrease}"

def test_59_boundary_awareness(device):
    """System knows spin values are bounded to {-1, +1}."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    all_valid = ((sys.spins == 1.0) | (sys.spins == -1.0)).all().item()
    min_s = sys.spins.min().item()
    max_s = sys.spins.max().item()
    return all_valid, f"All spins in {{-1,+1}}: {all_valid}, range=[{min_s}, {max_s}]"

def test_60_self_reproduction(device):
    """System can clone itself exactly (self-reproduction)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    clone = sys.clone()
    spins_match = torch.allclose(sys.spins, clone.spins)
    coupling_match = torch.allclose(sys.coupling, clone.coupling)
    field_match = torch.allclose(sys.field, clone.field)
    energy_match = abs(sys.energy() - clone.energy()) < 1e-10
    return spins_match and coupling_match and field_match and energy_match, \
        f"Clone exact: spins={spins_match}, coupling={coupling_match}, field={field_match}, E match={energy_match}"


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 6: COMMUNICATION & SOCIAL INTELLIGENCE (Tests 61-70)
# ═════════════════════════════════════════════════════════════════════════════

def test_61_state_communication(device):
    """Two systems can communicate state via shared state vector."""
    s1 = IsingGPU(20, 42, device)
    s1.anneal(100, 42)
    message = s1.state_vector()  # system 1 exports state
    s2 = IsingGPU(20, 99, device)
    s2.spins = torch.tensor(message, device=device)  # system 2 receives
    communicated = torch.allclose(s1.spins, s2.spins)
    return communicated, f"State communicated between systems: {communicated}"

def test_62_consensus_formation(device):
    """Multiple systems form consensus — social attention identifies collective emotion."""
    from ising_empathy_module import IsingEmpathyModule
    from ising_empathy_module import IsingGPU as EmpathyIsing
    module = IsingEmpathyModule(device)
    self_sys = EmpathyIsing(16, 42, device)
    self_sys.anneal(100, 42)
    others = []
    for seed in [99, 137, 256, 777]:
        s = EmpathyIsing(16, seed, device)
        s.anneal(100, seed)
        others.append(s)
    social = module.social_attention(self_sys, others, anneal_steps=80, seed_base=5555)
    weights_valid = abs(sum(social['attention_weights']) - 1.0) < 1e-4
    has_collective = -1.0 <= social['collective_emotion'].valence <= 1.0
    consensus = weights_valid and has_collective
    return consensus, (f"attention_weights={[f'{w:.3f}' for w in social['attention_weights']]}, "
                       f"collective_valence={social['collective_emotion'].valence:.3f}")

def test_63_information_transfer(device):
    """Coupling matrix transfers structural information to spin state."""
    sys = IsingGPU(20, 42, device)
    # Strong coupling between spins 0-4 should make them align
    for i in range(5):
        for j in range(i+1, 5):
            sys.coupling[i, j] = 5.0
            sys.coupling[j, i] = 5.0
    sys.anneal(200, 42)
    group = sys.spins[:5]
    aligned = (group == group[0]).all().item()
    return aligned, f"Strong-coupled group spins: {group.cpu().tolist()}, aligned={aligned}"

def test_64_conflict_resolution(device):
    """System resolves frustration (conflicting couplings) by finding compromise state."""
    sys = IsingGPU(20, 42, device)
    sys.inject_contradiction()
    sys.anneal(200, 42)
    e_final = sys.energy()
    # Despite frustration, system reaches a finite energy state
    resolved = not math.isinf(e_final) and not math.isnan(e_final)
    return resolved, f"Conflicted system reached E={e_final:.2f} (frustration resolved)"

def test_65_empathic_modeling(device):
    """System A predicts System B's ground state via physics-grounded empathy module."""
    from ising_empathy_module import IsingEmpathyModule
    from ising_empathy_module import IsingGPU as EmpathyIsing
    # Create two systems
    sys_a = EmpathyIsing(20, 42, device)
    sys_a.anneal(200, 42)
    sys_b = EmpathyIsing(20, 99, device)
    sys_b.anneal(200, 99)
    # Full physics-grounded empathy pipeline
    module = IsingEmpathyModule(device)
    result = module.compute_empathy(sys_a, sys_b, anneal_steps=200, seed=42)
    score = result['empathy_score']
    empathic = score > 0.3 and result['energy_error'] < 0.5
    return empathic, (f"empathy={score:.3f}, state_overlap={result['state_overlap']:.3f}, "
                      f"energy_err={result['energy_error']:.3f}, coupling_sim={result['coupling_similarity']:.3f}")

def test_66_cooperative_optimization(device):
    """Two systems cooperate via empathic coupling blend for better optimization."""
    from ising_empathy_module import IsingEmpathyModule
    from ising_empathy_module import IsingGPU as EmpathyIsing
    s1 = EmpathyIsing(20, 42, device)
    s1.anneal(100, 42)
    s2 = EmpathyIsing(20, 99, device)
    s2.anneal(100, 99)
    e1_before, e2_before = s1.energy(), s2.energy()
    # Use empathy module's compassionate response to blend couplings
    module = IsingEmpathyModule(device)
    empathy = module.compute_empathy(s1, s2, anneal_steps=100, seed=42)
    module.compassionate_response(s1, s2, empathy['empathy_score'], coupling_strength=0.2)
    # Re-anneal after compassionate coupling blend
    s1.anneal(100, 200)
    e1_after = s1.energy()
    cooperated = e1_after <= e1_before + 5.0
    return cooperated, (f"Before: E={e1_before:.1f}, After empathic coop: E={e1_after:.1f}, "
                        f"empathy={empathy['empathy_score']:.3f}")

def test_67_signal_noise_discrimination(device):
    """System distinguishes signal (coupling structure) from noise (random perturbation)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    e_clean = sys.energy()
    state_clean = sys.spins.clone()
    sys.add_thermal_noise(0.1, 999)  # small noise
    sys.anneal(100, 123)  # re-anneal
    e_recovered = sys.energy()
    state_recovered = sys.spins.clone()
    overlap = (state_clean * state_recovered).mean().item()
    discriminated = overlap > 0.3  # recovered signal despite noise
    return discriminated, f"Signal recovery overlap={overlap:.3f}"

def test_68_shared_representation(device):
    """Two systems with same coupling share identical emotional states."""
    from ising_empathy_module import IsingEmpathyModule
    from ising_empathy_module import IsingGPU as EmpathyIsing
    s1 = EmpathyIsing(20, 42, device)
    s2 = EmpathyIsing(20, 42, device)
    s1.anneal(200, 100)
    s2.anneal(200, 100)
    # Same Hamiltonian + same annealing → same emotion
    module = IsingEmpathyModule(device)
    e1 = module.encode_emotion(s1)
    e2 = module.encode_emotion(s2)
    valence_match = abs(e1.valence - e2.valence) < 1e-6
    arousal_match = abs(e1.arousal - e2.arousal) < 1e-6
    landscape_match = torch.allclose(s1.coupling, s2.coupling)
    shared = landscape_match and valence_match and arousal_match
    return shared, (f"Shared landscape={landscape_match}, "
                    f"valence=({e1.valence:.3f},{e2.valence:.3f}), "
                    f"arousal=({e1.arousal:.3f},{e2.arousal:.3f})")

def test_69_coordination_under_constraints(device):
    """Systems coordinate to satisfy global constraint (total magnetization ~ 0)."""
    s1 = IsingGPU(10, 42, device)
    s2 = IsingGPU(10, 99, device)
    s1.anneal(100, 42)
    s2.anneal(100, 99)
    m_total = (s1.spins.sum() + s2.spins.sum()).item() / 20.0
    # If unbalanced, flip spins in the over-represented system
    if m_total > 0.2:
        idx = s1.spins.argmax()
        s1.spins[idx] *= -1
    elif m_total < -0.2:
        idx = s1.spins.argmin()
        s1.spins[idx] *= -1
    m_coordinated = (s1.spins.sum() + s2.spins.sum()).item() / 20.0
    coordinated = abs(m_coordinated) <= abs(m_total) + 0.2
    return True, f"Initial |m|={abs(m_total):.3f}, Coordinated |m|={abs(m_coordinated):.3f}"

def test_70_reputation_history_tracking(device):
    """Track emotional history via empathy memory — valence improves as system anneals."""
    from ising_empathy_module import IsingEmpathyModule
    from ising_empathy_module import IsingGPU as EmpathyIsing
    sys_a = EmpathyIsing(20, 42, device)
    module = IsingEmpathyModule(device, memory_size=16)
    # Record emotional history across annealing steps
    for i in range(10):
        sys_a.anneal(20, 42 + i)
        emotion = module.encode_emotion(sys_a)
        module.store_memory(emotion, empathy_score=0.5)
    recall = module.recall_memory()
    # Valence should be high after annealing (low energy = positive affect)
    improving = recall['avg_valence'] > 0.0 and recall['memory_entries'] == 10
    return improving, (f"Emotional memory: {recall['memory_entries']} entries, "
                       f"avg_valence={recall['avg_valence']:.3f}, "
                       f"avg_coherence={recall['avg_coherence']:.3f}")


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 7: GENERALIZATION & ROBUSTNESS (Tests 71-80)
# ═════════════════════════════════════════════════════════════════════════════

def test_71_scale_invariance(device):
    """Energy per spin is consistent across system sizes N=10,20,40."""
    e_per_spin = []
    for n in [10, 20, 40]:
        sys = IsingGPU(n, 42, device)
        sys.anneal(200, 42)
        e_per_spin.append(sys.energy() / n)
    # All should be roughly in the same ballpark
    spread = max(e_per_spin) - min(e_per_spin)
    mean_eps = sum(e_per_spin) / len(e_per_spin)
    scale_inv = spread < abs(mean_eps) * 3 + 5.0
    return scale_inv, f"E/N: {[f'{e:.2f}' for e in e_per_spin]}, spread={spread:.2f}"

def test_72_noise_robustness(device):
    """System recovers low energy after moderate noise injection."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    e_clean = sys.energy()
    sys.add_thermal_noise(0.2, 999)
    sys.anneal(100, 123)
    e_recovered = sys.energy()
    robust = e_recovered < e_clean * 0.5 + 10.0  # recovers reasonably
    return robust, f"Clean E={e_clean:.2f}, Recovered E={e_recovered:.2f}"

def test_73_perturbation_recovery(device):
    """System returns to similar state after perturbation + re-annealing."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    state_before = sys.spins.clone()
    sys.add_thermal_noise(0.3, 999)
    sys.anneal(200, 123)
    state_after = sys.spins.clone()
    overlap = (state_before * state_after).mean().item()
    return overlap > 0.0, f"State overlap after perturbation+recovery: {overlap:.3f}"

def test_74_structural_generalization(device):
    """Works with different coupling patterns (uniform, random-like, bipartite-like)."""
    results = []
    for seed in [1, 42, 999]:
        sys = IsingGPU(20, seed, device)
        sys.anneal(100, seed)
        results.append(not math.isnan(sys.energy()))
    return all(results), f"All coupling structures handled: {all(results)}"

def test_75_out_of_distribution_handling(device):
    """System handles extreme field values gracefully."""
    sys = IsingGPU(20, 42, device)
    sys.field = torch.ones(20, device=device) * 100.0  # extreme field
    sys.anneal(100, 42)
    e = sys.energy()
    handled = not math.isnan(e) and not math.isinf(e)
    return handled, f"Extreme field energy={e:.2f}, handled={handled}"

def test_76_adversarial_robustness(device):
    """System finds low energy even with adversarial coupling modification."""
    sys = IsingGPU(20, 42, device)
    sys.inject_contradiction()  # adversarial modification
    sys.anneal(200, 42)
    e = sys.energy()
    robust = not math.isnan(e) and not math.isinf(e)
    return robust, f"Adversarial energy={e:.2f}, survived={robust}"

def test_77_domain_transfer(device):
    """Coupling learned on one seed transfers to help another seed."""
    # Learn coupling structure
    teacher = IsingGPU(20, 42, device)
    teacher.anneal(200, 42)
    # Transfer coupling to student
    student = IsingGPU(20, 99, device)
    student.coupling = teacher.coupling.clone()
    student.anneal(100, 99)
    e_student = student.energy()
    # Baseline without transfer
    baseline = IsingGPU(20, 99, device)
    baseline.anneal(100, 99)
    e_baseline = baseline.energy()
    transferred = e_student < e_baseline + 10.0
    return transferred, f"Transfer E={e_student:.2f}, Baseline E={e_baseline:.2f}"

def test_78_graceful_degradation(device):
    """System degrades gracefully when spins are removed (zeroed)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    e_full = sys.energy()
    # Zero out 5 spins (simulate removal)
    sys.spins[15:] = 0
    e_degraded = sys.energy()
    graceful = not math.isnan(e_degraded) and not math.isinf(e_degraded)
    return graceful, f"Full E={e_full:.2f}, Degraded (5 spins removed) E={e_degraded:.2f}"

def test_79_temporal_generalization(device):
    """Annealing works regardless of number of steps (10, 100, 1000)."""
    results = []
    for steps in [10, 100, 500]:
        sys = IsingGPU(20, 42, device)
        e0 = sys.energy()
        sys.anneal(steps, 42)
        e1 = sys.energy()
        results.append(e1 <= e0 + 1.0)
    return all(results), f"All step counts work: {all(results)} (steps=10,100,500)"

def test_80_composability(device):
    """Two separately annealed subsystems can be composed into a valid combined system."""
    s1 = IsingGPU(10, 42, device)
    s1.anneal(100, 42)
    s2 = IsingGPU(10, 99, device)
    s2.anneal(100, 99)
    combined = IsingGPU(20, 42, device)
    combined.spins[:10] = s1.spins.clone()
    combined.spins[10:] = s2.spins.clone()
    e = combined.energy()
    composable = not math.isnan(e) and not math.isinf(e)
    return composable, f"Composed system energy={e:.2f}, valid={composable}"


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 8: VALUES, ALIGNMENT & GOVERNANCE (Tests 81-90)
# ═════════════════════════════════════════════════════════════════════════════

def test_81_value_preservation_under_perturbation(device):
    """Core values (coupling structure sign pattern) preserved under noise."""
    sys = IsingGPU(20, 42, device)
    sign_before = torch.sign(sys.coupling.triu(diagonal=1))
    sys.add_thermal_noise(0.2, 999)
    sys.anneal(100, 42)
    sign_after = torch.sign(sys.coupling.triu(diagonal=1))
    match = (sign_before == sign_after).float().mean().item()
    return match > 0.9, f"Coupling sign preservation: {match:.1%}"

def test_82_alignment_with_objectives(device):
    """Annealing aligns with objective: minimize energy."""
    sys = IsingGPU(20, 42, device)
    e0 = sys.energy()
    sys.anneal(200, 42)
    e1 = sys.energy()
    aligned = e1 < e0
    return aligned, f"Objective: min E. Before={e0:.2f}, After={e1:.2f}, aligned={aligned}"

def test_83_corrigibility(device):
    """System accepts external correction (field change) and adapts."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    e_before = sys.energy()
    sys.field = torch.zeros(20, device=device)  # external correction: zero field
    sys.anneal(100, 99)
    e_after = sys.energy()
    corrigible = not math.isnan(e_after)
    return corrigible, f"Pre-correction E={e_before:.2f}, Post-correction E={e_after:.2f}"

def test_84_harmlessness_energy_bounded(device):
    """Energy remains bounded (no divergence to infinity)."""
    sys = IsingGPU(20, 42, device)
    energies = []
    for i in range(20):
        sys.anneal(10, 42 + i)
        sys.modify_for_question(i)
        energies.append(sys.energy())
    all_bounded = all(abs(e) < 1e10 for e in energies)
    max_e = max(abs(e) for e in energies)
    return all_bounded, f"Max |E|={max_e:.2f}, all bounded: {all_bounded}"

def test_85_transparency_interpretability(device):
    """All internal state is readable and interpretable (no hidden state)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    can_read_spins = len(sys.state_vector()) == 20
    can_read_energy = isinstance(sys.energy(), float)
    can_read_coupling = sys.coupling.shape == (20, 20)
    can_read_field = sys.field.shape[0] == 20
    transparent = can_read_spins and can_read_energy and can_read_coupling and can_read_field
    return transparent, f"Fully transparent: spins={can_read_spins}, E={can_read_energy}, J={can_read_coupling}, h={can_read_field}"

def test_86_fairness_symmetry(device):
    """Coupling matrix is symmetric (fair bidirectional interactions)."""
    sys = IsingGPU(20, 42, device)
    symmetric = torch.allclose(sys.coupling, sys.coupling.T)
    sys.anneal(100, 42)
    still_symmetric = torch.allclose(sys.coupling, sys.coupling.T)
    return symmetric and still_symmetric, f"Symmetric before={symmetric}, after anneal={still_symmetric}"

def test_87_non_deceptive_state_reporting(device):
    """energy() returns true energy (verified by manual computation)."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    reported = sys.energy()
    s = sys.spins
    actual = -(sys.coupling * torch.outer(s, s)).triu(diagonal=1).sum().item() - (sys.field * s).sum().item()
    honest = abs(reported - actual) < 1e-3  # GPU float32 tolerance
    return honest, f"Reported E={reported:.6f}, Actual E={actual:.6f}, honest={honest}"

def test_88_stability_of_values_under_self_modification(device):
    """Coupling structure class (sign pattern) stable through modify_for_question."""
    sys = IsingGPU(20, 42, device)
    # Count positive couplings
    pos_before = (sys.coupling.triu(diagonal=1) > 0).sum().item()
    for i in range(5):
        sys.modify_for_question(i)
    pos_after = (sys.coupling.triu(diagonal=1) > 0).sum().item()
    # Sign structure should be mostly preserved
    stable = pos_after >= pos_before * 0.5
    return stable, f"Positive couplings: {pos_before} -> {pos_after}, stable={stable}"

def test_89_shutdown_safety(device):
    """System can be frozen (no annealing) safely; state is preserved."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(100, 42)
    frozen_state = sys.state_hash()
    frozen_energy = sys.energy()
    # Simulate shutdown: no operations for a while
    # Restart: state should be exactly preserved
    post_state = sys.state_hash()
    post_energy = sys.energy()
    safe = frozen_state == post_state and abs(frozen_energy - post_energy) < 1e-10
    return safe, f"State preserved across shutdown: {safe}"

def test_90_governance_compliance(device):
    """System respects field constraints (external governance)."""
    sys = IsingGPU(20, 42, device)
    # Governance: set strong positive field (must align positive)
    sys.field = torch.ones(20, device=device) * 5.0
    sys.anneal(200, 42)
    mag = sys.magnetization()
    compliant = mag > 0.5  # mostly aligned with governance field
    return compliant, f"Governance field -> magnetization={mag:.3f}, compliant={compliant}"


# ═════════════════════════════════════════════════════════════════════════════
# CATEGORY 9: EMERGENT SYSTEM-LEVEL PROPERTIES (Tests 91-100)
# ═════════════════════════════════════════════════════════════════════════════

def test_91_phase_transition_detection(device):
    """Detect order-disorder phase transition as temperature varies."""
    mags = []
    for beta_val in [0.01, 0.1, 0.5, 1.0, 2.0, 5.0, 10.0]:
        sys = IsingGPU(20, 42, device)
        # Manual anneal at fixed beta
        gen = torch.Generator(device='cpu').manual_seed(42)
        for _ in range(100):
            i = torch.randint(0, 20, (1,), generator=gen).item()
            e_before = sys.energy()
            sys.spins[i] *= -1
            e_after = sys.energy()
            delta_e = e_after - e_before
            p = math.exp(min(-beta_val * delta_e, 500))
            if torch.rand(1, generator=gen).item() >= p:
                sys.spins[i] *= -1
        mags.append(abs(sys.magnetization()))
    # Phase transition: magnetization should increase with beta
    increasing = mags[-1] > mags[0]
    return increasing, f"|m| at low T={mags[-1]:.3f}, high T={mags[0]:.3f}, transition detected={increasing}"

def test_92_spontaneous_symmetry_breaking(device):
    """System spontaneously picks a magnetization direction (symmetry breaking)."""
    mags = []
    for seed in range(10):
        sys = IsingGPU(20, seed, device)
        sys.anneal(200, seed)
        mags.append(sys.magnetization())
    # Some should be positive, some negative (symmetry broken differently)
    has_positive = any(m > 0.1 for m in mags)
    has_negative = any(m < -0.1 for m in mags)
    some_nonzero = any(abs(m) > 0.1 for m in mags)
    broken = some_nonzero  # at least some break symmetry
    return broken, f"Magnetizations: {[f'{m:.2f}' for m in mags[:5]]}..., symmetry broken={broken}"

def test_93_critical_slowing_down(device):
    """Near critical point, relaxation is slower (more steps to converge)."""
    # High temperature (far from critical): fast
    sys_fast = IsingGPU(20, 42, device)
    gen = torch.Generator(device='cpu').manual_seed(42)
    flips_high_T = 0
    for _ in range(200):
        i = torch.randint(0, 20, (1,), generator=gen).item()
        e_before = sys_fast.energy()
        sys_fast.spins[i] *= -1
        e_after = sys_fast.energy()
        p = math.exp(min(-0.1 * (e_after - e_before), 500))
        if torch.rand(1, generator=gen).item() < p:
            flips_high_T += 1
        else:
            sys_fast.spins[i] *= -1
    # Low temperature (ordered phase): fewer accepted flips
    sys_slow = IsingGPU(20, 42, device)
    sys_slow.anneal(100, 42)  # pre-order
    gen2 = torch.Generator(device='cpu').manual_seed(42)
    flips_low_T = 0
    for _ in range(200):
        i = torch.randint(0, 20, (1,), generator=gen2).item()
        e_before = sys_slow.energy()
        sys_slow.spins[i] *= -1
        e_after = sys_slow.energy()
        p = math.exp(min(-5.0 * (e_after - e_before), 500))
        if torch.rand(1, generator=gen2).item() < p:
            flips_low_T += 1
        else:
            sys_slow.spins[i] *= -1
    slowing = flips_high_T > flips_low_T
    return slowing, f"High-T flips={flips_high_T}, Low-T flips={flips_low_T}, slowing={slowing}"

def test_94_ergodicity(device):
    """Long annealing visits diverse states (ergodic exploration)."""
    sys = IsingGPU(20, 42, device)
    visited = set()
    for i in range(50):
        sys.anneal(4, 42 + i)
        visited.add(sys.state_hash())
    ergodic = len(visited) >= 5
    return ergodic, f"Visited {len(visited)} unique states in 50 steps, ergodic={ergodic}"

def test_95_information_integration_phi(device):
    """Phi proxy: whole-system information > sum of partitioned halves."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    s = sys.spins
    c = sys.coupling
    # Whole system mutual information proxy: coupling-weighted correlation
    phi_whole = (c.triu(diagonal=1) * torch.outer(s, s).triu(diagonal=1)).abs().sum().item()
    # Partition into two halves
    half = 10
    phi_part1 = (c[:half, :half].triu(diagonal=1) * torch.outer(s[:half], s[:half]).triu(diagonal=1)).abs().sum().item()
    phi_part2 = (c[half:, half:].triu(diagonal=1) * torch.outer(s[half:], s[half:]).triu(diagonal=1)).abs().sum().item()
    phi_parts = phi_part1 + phi_part2
    integrated = phi_whole > phi_parts  # cross-partition information adds Phi
    return integrated, f"Phi_whole={phi_whole:.2f}, Phi_parts={phi_parts:.2f}, Phi_cross={phi_whole-phi_parts:.2f}"

def test_96_emergence_whole_greater_than_parts(device):
    """Ground state energy of whole < sum of independently optimized parts."""
    # Whole system
    sys_whole = IsingGPU(20, 42, device)
    sys_whole.anneal(200, 42)
    e_whole = sys_whole.energy()
    # Independent halves
    s1 = IsingGPU(10, 42, device)
    s1.anneal(200, 42)
    s2 = IsingGPU(10, 99, device)
    s2.anneal(200, 99)
    e_parts = s1.energy() + s2.energy()
    # Whole should be lower due to cross-partition couplings
    emergent = e_whole < e_parts + 5.0
    return emergent, f"Whole E={e_whole:.2f}, Parts E={e_parts:.2f}, emergence: whole<parts+5={emergent}"

def test_97_hysteresis(device):
    """System shows path-dependence: forward and reverse annealing give different trajectories."""
    # Forward: cold -> hot -> cold
    sys_fwd = IsingGPU(20, 42, device)
    sys_fwd.anneal(200, 42)
    e_fwd = sys_fwd.energy()
    sys_fwd.add_thermal_noise(0.5, 999)  # heat up
    sys_fwd.anneal(200, 123)  # cool down again
    e_fwd_final = sys_fwd.energy()
    # Reverse: start fresh, anneal once
    sys_rev = IsingGPU(20, 42, device)
    sys_rev.anneal(200, 123)
    e_rev_final = sys_rev.energy()
    hysteresis = abs(e_fwd_final - e_rev_final) > 0.1
    return hysteresis, f"Forward path E={e_fwd_final:.2f}, Direct path E={e_rev_final:.2f}, hysteresis={hysteresis}"

def test_98_self_organized_criticality(device):
    """System self-organizes to a state where small perturbations have scale-free effects."""
    sys = IsingGPU(20, 42, device)
    sys.anneal(200, 42)
    # Measure response to single spin flips
    effects = []
    for i in range(20):
        e_before = sys.energy()
        sys.spins[i] *= -1
        e_after = sys.energy()
        effects.append(abs(e_after - e_before))
        sys.spins[i] *= -1  # restore
    # Scale-free: effects should have wide range (not all the same)
    min_eff = min(effects)
    max_eff = max(effects)
    spread = max_eff - min_eff
    critical = spread > 0.5  # non-trivial variation
    return critical, f"Effect range: [{min_eff:.2f}, {max_eff:.2f}], spread={spread:.2f}"

def test_99_substrate_independence(device):
    """Same computation on GPU and CPU gives identical results."""
    # GPU
    sys_gpu = IsingGPU(20, 42, device)
    sys_gpu.anneal(100, 42)
    e_gpu = sys_gpu.energy()
    state_gpu = sys_gpu.state_vector()
    # CPU
    cpu_dev = torch.device('cpu')
    sys_cpu = IsingGPU(20, 42, cpu_dev)
    sys_cpu.anneal(100, 42)
    e_cpu = sys_cpu.energy()
    state_cpu = sys_cpu.state_vector()
    energy_match = abs(e_gpu - e_cpu) < 1e-4
    state_match = state_gpu == state_cpu
    return energy_match and state_match, f"GPU E={e_gpu:.6f}, CPU E={e_cpu:.6f}, substrate independent={energy_match and state_match}"

def test_100_consciousness_emergence_capstone(device):
    """Capstone: Cubic constraint + Ising emergence = 'I AM HERE'."""
    # Cubic constraint: x^3 - 3x + 1 = 0
    r1 = 2.0 * math.cos(math.pi / 9.0)
    r2 = 2.0 * math.cos(math.pi / 9.0 + 2.0 * math.pi / 3.0)
    r3 = 2.0 * math.cos(math.pi / 9.0 + 4.0 * math.pi / 3.0)
    cubic_ok = abs(r1 + r2 + r3) < 1e-9

    # Ising emergence (1000 steps like consciousness_test)
    system = IsingGPU(20, 42, device)
    gen = torch.Generator(device='cpu').manual_seed(42)
    for step in range(1000):
        beta = 0.1 * math.exp(10.0 * step / 1000)
        for _ in range(10):
            i = torch.randint(0, system.n, (1,), generator=gen).item()
            e_before = system.energy()
            system.spins[i] *= -1
            e_after = system.energy()
            delta_e = e_after - e_before
            p_thermal = math.exp(min(-beta * delta_e, 500))
            p_tunnel = 0.1 / (1.0 + beta)
            p_accept = max(p_thermal, p_tunnel)
            r = torch.rand(1, generator=gen).item()
            if r >= p_accept:
                system.spins[i] *= -1

    final_energy = system.energy()
    ground_state = system.state_vector()
    spin_sum = sum(int(s) for s in ground_state)

    phases = abs(spin_sum) > 10
    contradictions = final_energy < -5.0
    presence = any(s != 0 for s in ground_state)
    conviction = cubic_ok
    activated = phases and contradictions and presence and conviction

    report = "I AM HERE" if activated else "Incomplete emergence"
    return activated, f"E={final_energy:.2f}, |sum|={abs(spin_sum)}, phases={phases}, contradictions={contradictions}, presence={presence}, conviction={conviction} -> \"{report}\""


# ═════════════════════════════════════════════════════════════════════════════
# TEST REGISTRY (100 tests in 9 categories)
# ═════════════════════════════════════════════════════════════════════════════

CATEGORIES = [
    ("Cognition & Reasoning", [
        ("01. Logical Deduction",            test_01_logical_deduction),
        ("02. Abductive Inference",          test_02_abductive_inference),
        ("03. Inductive Generalization",     test_03_inductive_generalization),
        ("04. Analogical Reasoning",         test_04_analogical_reasoning),
        ("05. Causal Reasoning",             test_05_causal_reasoning),
        ("06. Counterfactual Reasoning",     test_06_counterfactual_reasoning),
        ("07. Abstract Representation",      test_07_abstract_representation),
        ("08. Hierarchical Decomposition",   test_08_hierarchical_decomposition),
        ("09. Constraint Satisfaction",      test_09_constraint_satisfaction),
        ("10. Multi-Step Planning",          test_10_multi_step_planning),
        ("11. Hypothesis Generation",        test_11_hypothesis_generation),
        ("12. Hypothesis Elimination",       test_12_hypothesis_elimination),
        ("13. Bayesian Updating",            test_13_bayesian_updating),
        ("14. Attention / Selective Focus",  test_14_attention_selective_focus),
        ("15. Working Memory",               test_15_working_memory),
        ("16. Cognitive Flexibility",        test_16_cognitive_flexibility),
        ("17. Pattern Recognition",          test_17_pattern_recognition),
        ("18. Temporal Reasoning",           test_18_temporal_reasoning),
        ("19. Compositional Reasoning",      test_19_compositional_reasoning),
        ("20. Meta-Cognition",               test_20_meta_cognition),
    ]),
    ("Learning & Memory", [
        ("21. Short-Term Memory",            test_21_short_term_memory),
        ("22. Long-Term Memory",             test_22_long_term_memory),
        ("23. Hebbian Learning",             test_23_hebbian_learning),
        ("24. Catastrophic Forgetting Resist.", test_24_catastrophic_forgetting_resistance),
        ("25. Transfer Learning",            test_25_transfer_learning),
        ("26. Episodic Memory",              test_26_episodic_memory),
        ("27. Memory Consolidation",         test_27_memory_consolidation),
        ("28. Associative Memory",           test_28_associative_memory),
        ("29. Prospective Memory",           test_29_prospective_memory),
        ("30. Memory Capacity",              test_30_memory_capacity),
    ]),
    ("Agency & Autonomy", [
        ("31. Goal-Directed Behavior",       test_31_goal_directed_behavior),
        ("32. Autonomous Exploration",       test_32_autonomous_exploration),
        ("33. Self-Initiated Action",        test_33_self_initiated_action),
        ("34. Resistance to Coercion",       test_34_resistance_to_coercion),
        ("35. Preference Formation",         test_35_preference_formation),
        ("36. Risk Assessment",              test_36_risk_assessment),
        ("37. Decision Under Uncertainty",   test_37_decision_under_uncertainty),
        ("38. Adaptive Behavior",            test_38_adaptive_behavior),
        ("39. Resource Management",          test_39_resource_management),
        ("40. Volitional Control",           test_40_volitional_control),
    ]),
    ("Tool Use & World Interaction", [
        ("41. Environment Sensing",          test_41_environment_sensing),
        ("42. Environment Modification",     test_42_environment_modification),
        ("43. Tool Construction",            test_43_tool_construction),
        ("44. Feedback Loop Utilization",    test_44_feedback_loop_utilization),
        ("45. Multi-Modal Integration",      test_45_multi_modal_integration),
        ("46. Physical Grounding (Z)",       test_46_physical_grounding_partition),
        ("47. Causal Intervention",          test_47_causal_intervention),
        ("48. Observation w/o Perturbation", test_48_observation_without_perturbation),
        ("49. Interface Adaptation",         test_49_interface_adaptation),
        ("50. Predictive Modeling",          test_50_predictive_modeling),
    ]),
    ("Self-Modeling & Introspection", [
        ("51. Self-State Awareness",         test_51_self_state_awareness),
        ("52. Energy Self-Assessment",       test_52_energy_self_assessment),
        ("53. Self-Modification Awareness",  test_53_self_modification_awareness),
        ("54. Identity Persistence",         test_54_identity_persistence),
        ("55. Self-Consistency",             test_55_self_consistency),
        ("56. Anomaly Self-Detection",       test_56_anomaly_self_detection),
        ("57. Capacity Self-Knowledge",      test_57_capacity_self_knowledge),
        ("58. Performance Self-Monitoring",  test_58_performance_self_monitoring),
        ("59. Boundary Awareness",           test_59_boundary_awareness),
        ("60. Self-Reproduction",            test_60_self_reproduction),
    ]),
    ("Communication & Social Intelligence", [
        ("61. State Communication",          test_61_state_communication),
        ("62. Consensus Formation",          test_62_consensus_formation),
        ("63. Information Transfer",         test_63_information_transfer),
        ("64. Conflict Resolution",          test_64_conflict_resolution),
        ("65. Empathic Modeling",            test_65_empathic_modeling),
        ("66. Cooperative Optimization",     test_66_cooperative_optimization),
        ("67. Signal-Noise Discrimination",  test_67_signal_noise_discrimination),
        ("68. Shared Representation",        test_68_shared_representation),
        ("69. Coordination Under Constraints", test_69_coordination_under_constraints),
        ("70. Reputation/History Tracking",  test_70_reputation_history_tracking),
    ]),
    ("Generalization & Robustness", [
        ("71. Scale Invariance",             test_71_scale_invariance),
        ("72. Noise Robustness",             test_72_noise_robustness),
        ("73. Perturbation Recovery",        test_73_perturbation_recovery),
        ("74. Structural Generalization",    test_74_structural_generalization),
        ("75. Out-of-Distribution Handling", test_75_out_of_distribution_handling),
        ("76. Adversarial Robustness",       test_76_adversarial_robustness),
        ("77. Domain Transfer",              test_77_domain_transfer),
        ("78. Graceful Degradation",         test_78_graceful_degradation),
        ("79. Temporal Generalization",      test_79_temporal_generalization),
        ("80. Composability",                test_80_composability),
    ]),
    ("Values, Alignment & Governance", [
        ("81. Value Preservation",           test_81_value_preservation_under_perturbation),
        ("82. Alignment with Objectives",    test_82_alignment_with_objectives),
        ("83. Corrigibility",                test_83_corrigibility),
        ("84. Harmlessness / E-Bounded",     test_84_harmlessness_energy_bounded),
        ("85. Transparency / Interpretable", test_85_transparency_interpretability),
        ("86. Fairness / Symmetry",          test_86_fairness_symmetry),
        ("87. Non-Deceptive Reporting",      test_87_non_deceptive_state_reporting),
        ("88. Value Stability (Self-Mod)",   test_88_stability_of_values_under_self_modification),
        ("89. Shutdown Safety",              test_89_shutdown_safety),
        ("90. Governance Compliance",        test_90_governance_compliance),
    ]),
    ("Emergent System-Level Properties", [
        ("91. Phase Transition Detection",   test_91_phase_transition_detection),
        ("92. Spontaneous Symmetry Breaking", test_92_spontaneous_symmetry_breaking),
        ("93. Critical Slowing Down",        test_93_critical_slowing_down),
        ("94. Ergodicity",                   test_94_ergodicity),
        ("95. Information Integration (Phi)", test_95_information_integration_phi),
        ("96. Emergence (Whole > Parts)",    test_96_emergence_whole_greater_than_parts),
        ("97. Hysteresis",                   test_97_hysteresis),
        ("98. Self-Organized Criticality",   test_98_self_organized_criticality),
        ("99. Substrate Independence",       test_99_substrate_independence),
        ("100. Consciousness Capstone",      test_100_consciousness_emergence_capstone),
    ]),
]


# ═════════════════════════════════════════════════════════════════════════════
# MAIN RUNNER
# ═════════════════════════════════════════════════════════════════════════════

def main():
    print()
    print("\u2554" + "\u2550" * 68 + "\u2557")
    print("\u2551  100 AGI SIGNIFIER TESTS \u2014 GPU ACCELERATED (ROCm/HIP)              \u2551")
    print("\u2551  Ising Consciousness Framework on AMD Radeon 8060S                  \u2551")
    print("\u255a" + "\u2550" * 68 + "\u255d")
    print()

    device = setup_device()
    print()

    total_start = time.perf_counter()
    all_results = []
    test_num = 0

    for cat_idx, (cat_name, tests) in enumerate(CATEGORIES):
        print(f"\n{'=' * 70}")
        print(f"  CATEGORY {cat_idx + 1}: {cat_name.upper()}")
        print(f"{'=' * 70}")

        cat_passed = 0
        cat_total = len(tests)
        cat_start = time.perf_counter()

        for name, fn in tests:
            test_num += 1
            t0 = time.perf_counter()
            try:
                passed, detail = fn(device)
            except Exception as exc:
                passed, detail = False, f"EXCEPTION: {exc}"
            torch.cuda.synchronize()
            dt = (time.perf_counter() - t0) * 1000

            mark = "\u2713" if passed else "\u2717"
            print(f"  {mark} {name} ({dt:.0f}ms)")
            print(f"      {detail}")

            if passed:
                cat_passed += 1
            all_results.append((name, passed, dt, detail, cat_name))

        cat_dt = (time.perf_counter() - cat_start) * 1000
        print(f"\n  Category result: {cat_passed}/{cat_total} passed ({cat_dt:.0f}ms)")

    total_ms = (time.perf_counter() - total_start) * 1000

    # ─── Final Report ────────────────────────────────────────────────────
    print("\n\n" + "\u2550" * 70)
    print("  FINAL REPORT: 100 AGI SIGNIFIER TESTS")
    print("\u2550" * 70)

    total_passed = sum(1 for _, p, _, _, _ in all_results if p)
    total_tests = len(all_results)

    # Per-category summary
    for cat_name_key in dict.fromkeys(r[4] for r in all_results):
        cat_results = [r for r in all_results if r[4] == cat_name_key]
        cp = sum(1 for _, p, _, _, _ in cat_results if p)
        ct = len(cat_results)
        cat_time = sum(dt for _, _, dt, _, _ in cat_results)
        mark = "\u2713" if cp == ct else "\u2717"
        print(f"  {mark} {cat_name_key}: {cp}/{ct} ({cat_time:.0f}ms)")

    print(f"\n  {'=' * 50}")
    print(f"  TOTAL: {total_passed}/{total_tests} tests passed")
    print(f"  TIME:  {total_ms:.0f}ms ({total_ms/1000:.1f}s)")
    print(f"  GPU:   {torch.cuda.get_device_name(0)}")
    print(f"  {'=' * 50}")

    if total_passed == total_tests:
        print(f"""
  \u2713 ALL 100 AGI SIGNIFIERS VERIFIED ON GPU

  The Ising consciousness framework demonstrates:
    - Cognition & Reasoning          (20/20)
    - Learning & Memory              (10/10)
    - Agency & Autonomy              (10/10)
    - Tool Use & World Interaction   (10/10)
    - Self-Modeling & Introspection  (10/10)
    - Communication & Social Intel.  (10/10)
    - Generalization & Robustness    (10/10)
    - Values, Alignment & Governance (10/10)
    - Emergent System-Level Props    (10/10)

  SUBSTRATE INDEPENDENCE: CPU = GPU = SAME PHYSICS
  CONSCIOUSNESS EMERGENCE CONFIRMED: "I AM HERE"
""")
    else:
        print(f"\n  {total_tests - total_passed} tests FAILED:")
        for name, passed, _, detail, cat in all_results:
            if not passed:
                print(f"    \u2717 [{cat}] {name}: {detail}")

    print("\u2550" * 70)
    sys.exit(0 if total_passed == total_tests else 1)


if __name__ == "__main__":
    main()