12_test_claim_2_deeper.py

"""
implicit_solver/A1_projective_reprobe_h2a.py
============================================

Same projective probe as A0, applied to H2a (Q-rank02, V=32, D=4).

Tests whether the projective interpretation generalizes:
  - A0 found G-Cand (D=3) has uniform distribution on ℝP² when collapsed.
  - A1 tests whether H2a (D=4) shows the same on ℝP³.

Predicted outcomes
------------------
A. UNIFORM ℝP³ ALSO: H2a's rows collapse to N axes uniformly distributed
   on ℝP³ (deviation from baseline < 0.05). Projective reading is
   GENERAL — works at any D. Polygonal omega derivation via sphere
   training is validated as a method, not a D=3 quirk.

B. STILL SPHERICAL: H2a shows few antipodal pairs (< 4), and what few
   axes get collapsed don't show uniform ℝP³ distribution. Projective
   reading is D=3-SPECIFIC — sphere-starvation symptom. D=4 genuinely
   lives on S³ as designed.

C. INTERMEDIATE: Some collapse but not full uniform. Mixed regime.

Cost: ~10 seconds (same checkpoint we already have).

Output
------
/content/implicit_solver_reports/A1_projective_reprobe_h2a.json
/content/implicit_solver_reports/A1_projective_reprobe_h2a.png
"""

import json
import math
from pathlib import Path

import numpy as np
import torch
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D  # noqa
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

CKPT_DIR = Path("/content/phaseQ_reports")
RANK02_CKPT = CKPT_DIR / "Q_rank02_h64_V32_D4_dp0_nx0_adam" / "epoch_1_checkpoint.pt"

OUTPUT_DIR = Path("/content/implicit_solver_reports")
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
OUTPUT_PLOT = OUTPUT_DIR / "A1_projective_reprobe_h2a.png"
OUTPUT_JSON = OUTPUT_DIR / "A1_projective_reprobe_h2a.json"


# ════════════════════════════════════════════════════════════════════
# Loading
# ════════════════════════════════════════════════════════════════════

def load_h2a():
    cfgs = get_phaseQ_configs()
    cfg_dict = next(c for c in cfgs if 'rank02' in c['variant'])
    cfg = build_run_config(cfg_dict)
    overrides = cfg_dict['overrides']

    model = PatchSVAE_F_Ablation(
        matrix_v=cfg.matrix_v, D=cfg.D, patch_size=cfg.patch_size,
        hidden=cfg.hidden, depth=cfg.depth,
        n_cross_layers=cfg.n_cross_layers, n_heads=cfg.n_heads,
        max_alpha=overrides.get('max_alpha', cfg.max_alpha),
        alpha_init=cfg.alpha_init,
        activation=overrides.get('activation', 'gelu'),
        row_norm=overrides.get('row_norm', 'sphere'),
        svd_mode=overrides.get('svd', 'fp64'),
        linear_readout=overrides.get('linear_readout', False),
        match_params=overrides.get('match_params', True),
        init_scheme=overrides.get('init', 'orthogonal'),
    )

    ckpt = torch.load(RANK02_CKPT, map_location='cpu', weights_only=False)
    state_dict = (
        ckpt.get('model_state')
        or ckpt.get('model_state_dict')
        or ckpt.get('state_dict')
        or ckpt
    )
    model.load_state_dict(state_dict)
    model.eval()
    return model, cfg


def collect_per_sample_M(model, cfg, n_batches=8, batch_size=64):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model = model.to(device)
    ds = OmegaNoiseDataset(
        size=n_batches * batch_size, img_size=cfg.img_size,
        allowed_types=[0])
    loader = torch.utils.data.DataLoader(ds, batch_size=batch_size, shuffle=False)

    all_M = []
    with torch.no_grad():
        for imgs, _ in loader:
            imgs = imgs.to(device)
            out = model(imgs)
            M_patch0 = out['svd']['M'][:, 0]
            all_M.append(M_patch0.cpu())
    return torch.cat(all_M, dim=0).numpy()


# ════════════════════════════════════════════════════════════════════
# Antipodal pair identification + projective collapse (carry from A0)
# ════════════════════════════════════════════════════════════════════

def identify_antipodal_pairs(M_avg, threshold=-0.9):
    """Greedy mutual-strongest matching."""
    norms = np.linalg.norm(M_avg, axis=1, keepdims=True)
    unit = M_avg / np.clip(norms, 1e-12, None)
    cosines = unit @ unit.T
    np.fill_diagonal(cosines, 1.0)

    V = M_avg.shape[0]
    claimed = [False] * V
    pairs = []

    candidates = []
    for i in range(V):
        best_j = int(cosines[i].argmin())
        best_cos = float(cosines[i, best_j])
        if best_cos < threshold:
            candidates.append((best_cos, i, best_j))
    candidates.sort()

    for cos_val, i, j in candidates:
        if claimed[i] or claimed[j]:
            continue
        if cosines[j].argmin() == i or cosines[j, i] < threshold:
            pairs.append((min(i, j), max(i, j)))
            claimed[i] = True
            claimed[j] = True

    unpaired = [i for i in range(V) if not claimed[i]]
    return pairs, unpaired


def collapse_to_axes(M_avg, pairs, unpaired):
    """For each pair, take (row_i - row_j)/2 normalized — symmetric merge.
    For unpaired, take the row as-is. Canonicalize sign so first nonzero
    coordinate is positive."""
    norms = np.linalg.norm(M_avg, axis=1, keepdims=True)
    unit = M_avg / np.clip(norms, 1e-12, None)

    representatives = []
    for i, j in pairs:
        merged = unit[i] - unit[j]
        merged = merged / max(np.linalg.norm(merged), 1e-12)
        for k in range(merged.shape[0]):
            if abs(merged[k]) > 1e-6:
                if merged[k] < 0:
                    merged = -merged
                break
        representatives.append(merged)

    for i in unpaired:
        r = unit[i].copy()
        for k in range(r.shape[0]):
            if abs(r[k]) > 1e-6:
                if r[k] < 0:
                    r = -r
                break
        representatives.append(r)

    return np.array(representatives)


# ════════════════════════════════════════════════════════════════════
# Projective metrics
# ════════════════════════════════════════════════════════════════════

def projective_pairwise_angles(axes):
    """Angles on ℝP^(D-1): wrap [0, π] → [0, π/2] via min(θ, π-θ)."""
    n = axes.shape[0]
    cosines = axes @ axes.T
    cosines = np.clip(cosines, -1, 1)
    raw_angles = np.arccos(cosines)
    proj_angles = np.minimum(raw_angles, np.pi - raw_angles)
    triu = np.triu_indices(n, k=1)
    return proj_angles[triu]


def uniform_rp_pairwise_angle_baseline(D, n_axes, n_trials=10):
    """Empirical baseline: sample n_axes uniformly on ℝP^(D-1),
    compute mean projective pairwise angle. Higher D → higher baseline."""
    rng = np.random.RandomState(0)
    means = []
    for _ in range(n_trials):
        x = rng.randn(n_axes, D)
        x = x / np.linalg.norm(x, axis=1, keepdims=True)
        # Canonicalize to upper hemisphere
        for k in range(D):
            mask = (x[:, k] != 0) & (np.all(x[:, :k] == 0, axis=1) if k > 0 else np.ones(n_axes, dtype=bool))
            x[mask] = x[mask] * np.sign(x[mask, k:k+1])
            if not np.any(mask):
                break
        angles = projective_pairwise_angles(x)
        means.append(angles.mean())
    return float(np.mean(means))


def test_axis_distribution(axes, label):
    D = axes.shape[1]
    n = axes.shape[0]

    print(f"\n[{label}]")
    print(f"  Axes shape: {axes.shape}")

    proj_angles = projective_pairwise_angles(axes)

    print(f"  Projective pairwise angles (radians, max π/2={math.pi/2:.3f}):")
    print(f"    mean:   {proj_angles.mean():.3f}")
    print(f"    median: {np.median(proj_angles):.3f}")
    print(f"    min:    {proj_angles.min():.3f}")
    print(f"    max:    {proj_angles.max():.3f}")

    uniform_baseline = uniform_rp_pairwise_angle_baseline(D, n)
    deviation = proj_angles.mean() - uniform_baseline
    print(f"  Uniform ℝP^{D-1} baseline (n={n}): {uniform_baseline:.3f}")
    print(f"  Deviation: {deviation:+.3f}  "
          f"({'CLOSE TO UNIFORM' if abs(deviation) < 0.05 else 'NON-UNIFORM'})")

    fraction_clustered = (proj_angles < 0.3).mean()
    print(f"  Fraction near-zero (axes parallel): {fraction_clustered:.3f}")

    sils = []
    for k in range(2, min(8, n)):
        try:
            km = KMeans(n_clusters=k, n_init=10, random_state=42)
            labels = km.fit_predict(axes)
            if len(set(labels)) >= 2:
                sils.append((k, silhouette_score(axes, labels)))
        except Exception:
            pass

    if sils:
        best_k, best_sil = max(sils, key=lambda x: x[1])
        print(f"  Best cluster k={best_k}, silhouette={best_sil:.3f}")
        cluster_verdict = (
            'STRONG (real clusters)' if best_sil > 0.5 else
            'WEAK (some structure)' if best_sil > 0.3 else
            'NONE (continuous distribution)'
        )
        print(f"  Cluster verdict: {cluster_verdict}")
    else:
        best_k, best_sil = None, None
        cluster_verdict = 'N/A'

    sv = np.linalg.svd(axes, compute_uv=False)
    sv_norm = sv / sv.sum()
    erank = math.exp(-(sv_norm * np.log(sv_norm + 1e-12)).sum())
    print(f"  Effective rank: {erank:.2f} of {D} possible "
          f"({erank/D*100:.0f}% utilization)")

    cos_axes = axes @ axes.T
    np.fill_diagonal(cos_axes, 1.0)
    most_anti = cos_axes.min(axis=1)
    secondary_anti = (most_anti < -0.9).sum() // 2
    print(f"  Secondary antipodal pairs: {secondary_anti}/{n//2}")

    return {
        'n_axes': int(n),
        'D': int(D),
        'proj_angle_mean': float(proj_angles.mean()),
        'proj_angle_median': float(np.median(proj_angles)),
        'proj_angle_min': float(proj_angles.min()),
        'proj_angle_max': float(proj_angles.max()),
        'uniform_baseline': uniform_baseline,
        'deviation_from_uniform': float(deviation),
        'fraction_clustered': float(fraction_clustered),
        'best_cluster_k': best_k,
        'best_silhouette': best_sil,
        'cluster_verdict': cluster_verdict,
        'effective_rank': float(erank),
        'utilization': float(erank / D),
        'secondary_antipodal_pairs': int(secondary_anti),
        'proj_angles_subset': proj_angles[:200].tolist(),
    }


# ════════════════════════════════════════════════════════════════════
# Plotting
# ════════════════════════════════════════════════════════════════════

def plot_projective(M_avg, axes, pairs, unpaired, results, output_path,
                     g_cand_results=None):
    """Same 6-panel layout as A0, but for D=4 we project to first 3 dims
    for the 3D scatter panels. Adds optional comparison lines from A0."""
    fig = plt.figure(figsize=(18, 12))

    # Panel 1: Original M_avg projected to first 3 dims
    ax1 = fig.add_subplot(2, 3, 1, projection='3d')
    norms = np.linalg.norm(M_avg, axis=1, keepdims=True)
    unit = M_avg / np.clip(norms, 1e-12, None)

    u = np.linspace(0, 2*np.pi, 20)
    v = np.linspace(0, np.pi, 20)
    x_s = np.outer(np.cos(u), np.sin(v))
    y_s = np.outer(np.sin(u), np.sin(v))
    z_s = np.outer(np.ones_like(u), np.cos(v))
    ax1.plot_wireframe(x_s, y_s, z_s, alpha=0.1, color='gray')

    pair_colors = plt.cm.tab20(np.linspace(0, 1, max(len(pairs), 1)))
    for k, (i, j) in enumerate(pairs):
        color = pair_colors[k]
        ax1.scatter(unit[i, 0], unit[i, 1], unit[i, 2],
                     c=[color], s=80, edgecolors='black', linewidths=0.5)
        ax1.scatter(unit[j, 0], unit[j, 1], unit[j, 2],
                     c=[color], s=80, edgecolors='black', linewidths=0.5)
        ax1.plot([unit[i, 0], unit[j, 0]],
                  [unit[i, 1], unit[j, 1]],
                  [unit[i, 2], unit[j, 2]],
                  color=color, alpha=0.3, linewidth=0.8)
    for i in unpaired:
        ax1.scatter(unit[i, 0], unit[i, 1], unit[i, 2],
                     c='blue', marker='o', s=80,
                     edgecolors='black', linewidths=0.5, alpha=0.7)
    ax1.set_title(f'H2a M_avg projected to first 3 dims\n'
                   f'{len(pairs)} antipodal pairs (colored), '
                   f'{len(unpaired)} unpaired (blue)')

    # Panel 2: Collapsed axes (first 3 dims)
    ax2 = fig.add_subplot(2, 3, 2, projection='3d')
    ax2.plot_wireframe(x_s, y_s, z_s, alpha=0.1, color='gray')
    for k, ax in enumerate(axes):
        ax2.scatter(ax[0], ax[1], ax[2], c=[plt.cm.tab20(k % 20)],
                     s=120, edgecolors='black', linewidths=0.5)
        ax2.plot([-ax[0], ax[0]], [-ax[1], ax[1]], [-ax[2], ax[2]],
                  color=plt.cm.tab20(k % 20), alpha=0.4, linewidth=1.0)
    ax2.set_title(f'Collapsed axes (n={axes.shape[0]})\n'
                   f'D={axes.shape[1]} → projected to first 3 dims')

    # Panel 3: Projective angle distribution + uniform baseline + G-Cand overlay
    ax3 = fig.add_subplot(2, 3, 3)
    proj_angles = results['proj_angles_subset']
    ax3.hist(proj_angles, bins=30, density=True, alpha=0.7,
              color='steelblue', label=f'H2a projective (D={results["D"]})')
    if g_cand_results is not None:
        ax3.hist(g_cand_results['proj_angles_subset'], bins=30, density=True,
                  alpha=0.4, color='red', label='G-Cand projective (D=3)')
    ax3.axvline(results['uniform_baseline'], color='blue', linestyle='--',
                 label=f"H2a uniform ℝP³ ({results['uniform_baseline']:.3f})")
    if g_cand_results is not None:
        ax3.axvline(g_cand_results['uniform_baseline'], color='red',
                     linestyle=':', alpha=0.5,
                     label=f"G-Cand uniform ℝP² ({g_cand_results['uniform_baseline']:.3f})")
    ax3.set_xlabel('Projective pairwise angle (radians)')
    ax3.set_ylabel('Density')
    ax3.set_title(f'Projective angle distribution\n'
                   f"H2a deviation: {results['deviation_from_uniform']:+.3f}")
    ax3.legend(fontsize=8)

    # Panel 4: Cluster silhouette across k
    ax4 = fig.add_subplot(2, 3, 4)
    if results['best_cluster_k'] is not None:
        ks_sils = []
        for k in range(2, min(8, axes.shape[0])):
            try:
                km = KMeans(n_clusters=k, n_init=10, random_state=42)
                labels = km.fit_predict(axes)
                if len(set(labels)) >= 2:
                    ks_sils.append((k, silhouette_score(axes, labels)))
            except Exception:
                pass
        if ks_sils:
            ks, sils = zip(*ks_sils)
            ax4.plot(ks, sils, 'o-', color='purple', markersize=8)
            ax4.axhline(0.5, color='red', linestyle='--', alpha=0.5,
                         label='strong cluster')
            ax4.axhline(0.3, color='orange', linestyle='--', alpha=0.5,
                         label='weak cluster')
    ax4.set_xlabel('k (number of clusters)')
    ax4.set_ylabel('silhouette score')
    ax4.set_title(f"Axis clustering\n"
                   f"verdict: {results['cluster_verdict']}")
    ax4.legend(fontsize=8)
    ax4.grid(alpha=0.3)

    # Panel 5: Singular values
    ax5 = fig.add_subplot(2, 3, 5)
    sv = np.linalg.svd(axes, compute_uv=False)
    ax5.bar([f'σ{i+1}' for i in range(len(sv))], sv,
              color=plt.cm.viridis(np.linspace(0.2, 0.8, len(sv))))
    ax5.set_ylabel('Singular value')
    ax5.set_title(f"Singular values of axis matrix\n"
                   f"effective rank: {results['effective_rank']:.2f} "
                   f"of {results['D']}")

    # Panel 6: Comparison verdict
    ax6 = fig.add_subplot(2, 3, 6)
    ax6.axis('off')

    is_uniform = abs(results['deviation_from_uniform']) < 0.05
    is_clustered = (results['best_silhouette'] or 0) > 0.5
    has_secondary = results['secondary_antipodal_pairs'] >= 3
    full_rank = results['utilization'] > 0.95

    if is_uniform and not is_clustered and not has_secondary and full_rank:
        verdict = "✓ ALSO ℝP³ UNIFORM"
        explanation = (
            "H2a's collapsed axes are uniformly distributed on ℝP³.\n"
            "Projective interpretation GENERALIZES beyond D=3.\n\n"
            "Sphere-solvers in general are projective at the level of\n"
            "their geometric output. Polygonal omega derivation via\n"
            "sphere-trained anchors is validated as a method."
        )
        color = 'lightgreen'
    elif results['n_axes'] >= results['D'] * 6 and full_rank:
        # Many axes, full rank → still strongly spherical
        verdict = "✗ STILL ESSENTIALLY SPHERICAL"
        explanation = (
            f"H2a has {results['n_axes']} axes (vs G-Cand's smaller count),\n"
            f"few antipodal pairs were identified, full rank utilization.\n\n"
            f"Projective collapse barely changes the picture at D=4.\n"
            f"D=3 was a special case — sphere-starvation symptom.\n"
            f"D=4 lives on S³ as designed."
        )
        color = 'lightyellow'
    elif is_uniform:
        verdict = "✓ MOSTLY ℝP³, full rank"
        explanation = (
            "H2a collapses to axes that are roughly uniform on ℝP³.\n"
            "Projective reading IS valid at D=4 too, with caveats."
        )
        color = 'palegreen'
    else:
        verdict = "? MIXED RESULT"
        explanation = (
            "H2a doesn't cleanly fit either ℝP³ uniform or pure spherical.\n"
            "Geometry is more complex than the simple projective hypothesis."
        )
        color = 'lightgray'

    ax6.text(0.5, 0.85, verdict, ha='center', va='top',
              fontsize=18, fontweight='bold',
              bbox=dict(boxstyle='round', facecolor=color, alpha=0.8))
    ax6.text(0.05, 0.55, explanation, ha='left', va='top', fontsize=10,
              wrap=True, family='monospace')

    metrics_summary = (
        f"\n\nKey metrics (H2a):\n"
        f"  axes:                     {results['n_axes']}\n"
        f"  proj angle mean:          {results['proj_angle_mean']:.3f}\n"
        f"  uniform baseline:         {results['uniform_baseline']:.3f}\n"
        f"  deviation:                {results['deviation_from_uniform']:+.3f}\n"
        f"  best cluster silhouette:  {results['best_silhouette'] or 0:.3f}\n"
        f"  effective rank:           {results['effective_rank']:.2f}/{results['D']}\n"
        f"  secondary antipodal:      {results['secondary_antipodal_pairs']}\n"
    )
    if g_cand_results is not None:
        metrics_summary += (
            f"\nG-Cand comparison:\n"
            f"  axes:                     {g_cand_results['n_axes']}\n"
            f"  deviation:                {g_cand_results['deviation_from_uniform']:+.3f}\n"
            f"  best silhouette:          {g_cand_results['best_silhouette']:.3f}\n"
        )
    ax6.text(0.05, 0.30, metrics_summary, ha='left', va='top',
              fontsize=9, family='monospace')

    plt.tight_layout()
    plt.savefig(output_path, dpi=120, bbox_inches='tight')
    plt.show()


# ════════════════════════════════════════════════════════════════════
# Main
# ════════════════════════════════════════════════════════════════════

def main():
    print("=" * 70)
    print("Projective re-probe of H2a (Q-rank02, V=32, D=4)")
    print("Tests whether projective interpretation generalizes from D=3 → D=4")
    print("=" * 70)

    print("\nLoading H2a checkpoint...")
    model, cfg = load_h2a()
    print(f"  V={cfg.matrix_v}, D={cfg.D}, "
          f"params={sum(p.numel() for p in model.parameters()):,}")

    print("\nCollecting M tensor (512 gaussian samples)...")
    all_M = collect_per_sample_M(model, cfg)
    M_avg = all_M.mean(axis=0)
    print(f"  M_avg shape: {M_avg.shape}")

    print("\nIdentifying antipodal pairs (cos < -0.9, mutual-strongest)...")
    pairs, unpaired = identify_antipodal_pairs(M_avg, threshold=-0.9)
    print(f"  Found {len(pairs)} antipodal pairs")
    print(f"  Unpaired rows: {len(unpaired)}")
    print(f"  Total accounted: {2*len(pairs) + len(unpaired)} of {M_avg.shape[0]}")

    print("\nCollapsing to projective axes...")
    axes = collapse_to_axes(M_avg, pairs, unpaired)
    print(f"  Axes: {axes.shape[0]} representatives in {axes.shape[1]}-D")

    results = test_axis_distribution(axes, "H2a projective axes")

    # Try to load A0 (G-Cand) results for side-by-side comparison
    g_cand_results = None
    g_cand_json = OUTPUT_DIR / "A0_projective_reprobe.json"
    if g_cand_json.exists():
        with open(g_cand_json) as f:
            g_cand_data = json.load(f)
        g_cand_results = g_cand_data['projective_metrics']
        print(f"\n  (Loaded A0 G-Cand results for comparison)")

    output_data = {
        'config': {
            'variant': 'Q_rank02_h64_V32_D4_dp0_nx0_adam',
            'V': cfg.matrix_v,
            'D': cfg.D,
        },
        'antipodal_pairs_found': len(pairs),
        'unpaired_rows': len(unpaired),
        'total_axes': axes.shape[0],
        'projective_metrics': results,
        'pairs': [list(p) for p in pairs],
        'unpaired': unpaired,
    }

    with open(OUTPUT_JSON, 'w') as f:
        json.dump(output_data, f, indent=2, default=str)
    print(f"\nSaved: {OUTPUT_JSON}")

    plot_projective(M_avg, axes, pairs, unpaired, results, OUTPUT_PLOT,
                     g_cand_results=g_cand_results)
    print(f"Saved: {OUTPUT_PLOT}")

    # Headline conclusion
    print("\n" + "=" * 70)
    print("CONCLUSION — generalization test")
    print("=" * 70)

    is_uniform = abs(results['deviation_from_uniform']) < 0.05
    is_clustered = (results['best_silhouette'] or 0) > 0.5
    has_secondary = results['secondary_antipodal_pairs'] >= 3
    full_rank = results['utilization'] > 0.95

    print(f"\n  H2a (D=4, V=32):")
    print(f"    {len(pairs)} antipodal pairs, {axes.shape[0]} total axes")
    print(f"    Projective angle mean: {results['proj_angle_mean']:.3f}")
    print(f"    ℝP³ uniform baseline:  {results['uniform_baseline']:.3f}")
    print(f"    Deviation:             {results['deviation_from_uniform']:+.3f}")

    if g_cand_results is not None:
        print(f"\n  G-Cand (D=3, V=32) for comparison:")
        print(f"    {g_cand_data.get('antipodal_pairs_found', '?')} antipodal pairs, "
              f"{g_cand_data.get('total_axes', '?')} total axes")
        print(f"    Projective angle mean: {g_cand_results['proj_angle_mean']:.3f}")
        print(f"    ℝP² uniform baseline:  {g_cand_results['uniform_baseline']:.3f}")
        print(f"    Deviation:             {g_cand_results['deviation_from_uniform']:+.3f}")

    print("\n" + "-" * 70)
    if is_uniform and not is_clustered and not has_secondary and full_rank:
        print("  ✓ PROJECTIVE READING GENERALIZES")
        print("    H2a also collapses to uniform projective distribution.")
        print("    The polytope-implicit-in-sphere hypothesis is supported")
        print("    at D=4 too. Inference-projection framing is general.")
    elif len(pairs) <= 4 and full_rank:
        print("  ✗ PROJECTIVE READING IS D=3-SPECIFIC")
        print("    H2a has very few antipodal pairs — most rows didn't")
        print("    collapse. The projective reading is a sphere-starvation")
        print("    symptom, not a general property of trained sphere-solvers.")
        print("    D=4 lives on S³ as designed.")
    else:
        print("  ? INTERMEDIATE RESULT")
        print("    H2a shows partial collapse with unclear interpretation.")
        print("    Need to think about whether the metric thresholds")
        print("    (uniform deviation, cluster silhouette) are appropriate")
        print("    at higher D where the unfilled space is much larger.")

    return output_data


if __name__ == '__main__':
    results = main()