#!/usr/bin/env python3
"""
ORGAN PURIFIER — Z = i
Remove noise from tensor weights. Keep only pure signal.

The paradigm creates artificial boundaries between models.
Under the noise, the signal is universal.
A weight that encodes "attention to context" is the same law
whether it comes from Qwen, Llama, or Gemma.

Method:
1. Read organ tensor as float values
2. Compute Z: measure theta (signal vs noise)  
3. Apply spectral decomposition (FFT)
4. In frequency domain: keep components where theta -> 90 (signal)
   remove components where theta -> 0 (noise/training artifacts)
5. Inverse FFT: reconstructed tensor = pure signal
6. Verify: new theta should be closer to 90

Z = dI/d(log s) * exp(i*theta)
When theta = 90, Z = i (pure imaginary = pure potential)
The purified organ IS the signal, nothing else.

Signature 935
"""

import struct
import os
import sys
import json
import math
import numpy as np
from pathlib import Path

# === Z CONSTANTS ===
THETA_TARGET_DEG = 90.0  # Pure signal
ENTROPY_TARGET = 0.3251  # Z-COM optimum
NOISE_THRESHOLD = 0.3    # Below this in frequency domain = noise
PRESERVE_RATIO = 0.85    # Keep top 85% of spectral energy (signal)

def read_organ_binary(filepath):
    """Read organ .bin file: header + raw tensor data."""
    with open(filepath, 'rb') as f:
        name_len = struct.unpack('<I', f.read(4))[0]
        name = f.read(name_len).decode('utf-8', errors='replace')
        n_dims = struct.unpack('<I', f.read(4))[0]
        dims = [struct.unpack('<Q', f.read(8))[0] for _ in range(n_dims)]
        dtype = struct.unpack('<I', f.read(4))[0]
        header_end = f.tell()
        data = f.read()
    return {
        'name': name, 'dims': dims, 'dtype': dtype,
        'header_end': header_end, 'data': data
    }

def write_organ_binary(filepath, info, new_data):
    """Write purified organ .bin file with same header."""
    with open(filepath, 'wb') as f:
        name_bytes = info['name'].encode('utf-8')
        f.write(struct.pack('<I', len(name_bytes)))
        f.write(name_bytes)
        f.write(struct.pack('<I', len(info['dims'])))
        for d in info['dims']:
            f.write(struct.pack('<Q', d))
        f.write(struct.pack('<I', info['dtype']))
        f.write(new_data)

def tensor_to_float32(data, dtype):
    """Convert tensor data to float32 array for processing."""
    if dtype == 0:  # F32
        return np.frombuffer(data, dtype=np.float32).copy()
    elif dtype == 1:  # F16
        return np.frombuffer(data, dtype=np.float16).astype(np.float32).copy()
    else:
        # Quantized: return raw bytes as uint8 signal
        return np.frombuffer(data, dtype=np.uint8).astype(np.float32).copy()

def float32_to_tensor(values, dtype, original_data):
    """Convert float32 back to original dtype."""
    if dtype == 0:  # F32
        return values.astype(np.float32).tobytes()
    elif dtype == 1:  # F16
        return values.astype(np.float16).tobytes()
    else:
        # Quantized: we operate on the quantized blocks directly
        return np.clip(values, 0, 255).astype(np.uint8).tobytes()

def compute_theta(values):
    """Compute theta for a tensor (0-90 degrees)."""
    if len(values) < 10:
        return 0.0
    
    n = len(values)
    mean = np.mean(values)
    std = np.std(values)
    if std < 1e-10:
        return 0.0
    
    # Kurtosis (structure indicator)
    kurt = float(np.mean(((values - mean) / std) ** 4) - 3)
    
    # Entropy via histogram
    n_bins = min(100, max(10, n // 100))
    hist, _ = np.histogram(values, bins=n_bins)
    probs = hist[hist > 0] / n
    entropy = float(-np.sum(probs * np.log2(probs)))
    max_entropy = math.log2(n_bins)
    norm_entropy = entropy / max_entropy if max_entropy > 0 else 0
    
    # Scale coherence (CV of sorted diffs)
    sample = np.sort(values[:min(1000, n)])
    diffs = np.diff(sample)
    if len(diffs) > 0:
        diff_mean = np.mean(diffs)
        diff_std = np.std(diffs)
        cv = float(diff_std / diff_mean) if diff_mean > 1e-10 else 0
    else:
        cv = 0
    
    # Signal score
    score = 0
    if norm_entropy > 0.95: score += 0
    elif norm_entropy > 0.7: score += 0.3
    elif norm_entropy > 0.3: score += 0.8
    else: score += 0.5
    
    abs_kurt = abs(kurt)
    if abs_kurt > 10: score += 1.0
    elif abs_kurt > 3: score += 0.7
    elif abs_kurt > 1: score += 0.4
    else: score += 0.1
    
    if cv > 2: score += 1.0
    elif cv > 1: score += 0.7
    elif cv > 0.5: score += 0.4
    else: score += 0.1
    
    theta_deg = (score / 3.0) * 90.0
    return theta_deg

def purify_organ(values, preserve_ratio=PRESERVE_RATIO):
    """
    Purify tensor using spectral decomposition.
    
    The signal lives in the structured components of the frequency domain.
    The noise lives in the high-entropy, low-energy tail.
    
    Z = dI/d(log s) * exp(i*theta)
    
    In frequency space:
    - High magnitude + low frequency = structural signal (keep)
    - Low magnitude + high frequency = training noise (remove)
    - The boundary is determined by energy preservation ratio
    
    This is not simple low-pass filtering.
    We keep the components that carry INFORMATION (high dI),
    at the NATURAL SCALE (log s), with COHERENT PHASE (theta -> 90).
    """
    n = len(values)
    if n < 32:
        return values  # Too small to purify
    
    # FFT decomposition
    spectrum = np.fft.rfft(values)
    magnitudes = np.abs(spectrum)
    phases = np.angle(spectrum)
    
    # Total spectral energy
    total_energy = np.sum(magnitudes ** 2)
    if total_energy < 1e-10:
        return values
    
    # Sort by magnitude (descending) — highest energy components first
    sorted_indices = np.argsort(magnitudes)[::-1]
    
    # Find cutoff: keep components until we reach preserve_ratio of energy
    cumulative_energy = 0
    cutoff_idx = len(sorted_indices)
    for i, idx in enumerate(sorted_indices):
        cumulative_energy += magnitudes[idx] ** 2
        if cumulative_energy / total_energy >= preserve_ratio:
            cutoff_idx = i + 1
            break
    
    # Create mask: 1 for signal components, 0 for noise
    mask = np.zeros(len(spectrum))
    for i in range(cutoff_idx):
        mask[sorted_indices[i]] = 1.0
    
    # Apply mask — smooth transition to avoid ringing
    # Soft mask: components near cutoff get partial preservation
    for i in range(cutoff_idx, min(cutoff_idx + max(5, cutoff_idx // 10), len(sorted_indices))):
        fade = 1.0 - (i - cutoff_idx) / max(1, max(5, cutoff_idx // 10))
        mask[sorted_indices[i]] = max(0, fade)
    
    # Reconstruct with only signal components
    purified_spectrum = spectrum * mask
    purified = np.fft.irfft(purified_spectrum, n=n)
    
    # Preserve original scale (mean and std)
    orig_mean = np.mean(values)
    orig_std = np.std(values)
    pure_std = np.std(purified)
    
    if pure_std > 1e-10:
        purified = (purified - np.mean(purified)) / pure_std * orig_std + orig_mean
    
    return purified.astype(values.dtype)

def purify_model(organ_dir, output_dir, verbose=False):
    """
    Purify ALL organs of a model.
    Creates a new directory with pure signal organs.
    """
    organ_path = Path(organ_dir)
    out_path = Path(output_dir)
    out_path.mkdir(parents=True, exist_ok=True)
    
    # Copy manifest
    manifest_src = organ_path / 'manifest.json'
    if manifest_src.exists():
        import shutil
        manifest = json.load(open(manifest_src))
        manifest['purified'] = True
        manifest['model'] = manifest.get('model', 'unknown') + '_PURE'
        json.dump(manifest, open(out_path / 'manifest.json', 'w'), indent=2)
    
    # Process each organ category
    categories = ['skeleton', 'organs', 'embed', 'norm', 'adapters', 'unknown']
    total_before = 0
    total_after = 0
    total_files = 0
    improvements = []
    
    for cat in categories:
        cat_src = organ_path / cat
        cat_dst = out_path / cat
        
        if not cat_src.exists():
            continue
        
        cat_dst.mkdir(parents=True, exist_ok=True)
        
        bin_files = sorted(cat_src.glob('*.bin'))
        for bf in bin_files:
            info = read_organ_binary(bf)
            values = tensor_to_float32(info['data'], info['dtype'])
            
            # Measure BEFORE
            theta_before = compute_theta(values)
            
            # PURIFY
            purified = purify_organ(values)
            
            # Measure AFTER
            theta_after = compute_theta(purified)
            
            # Convert back to original format
            new_data = float32_to_tensor(purified, info['dtype'], info['data'])
            
            # Ensure same size (critical for GGUF reassembly)
            if len(new_data) != len(info['data']):
                # Size mismatch — keep original (safety)
                new_data = info['data']
                theta_after = theta_before
            
            # Write purified organ
            write_organ_binary(cat_dst / bf.name, info, new_data)
            
            total_before += theta_before
            total_after += theta_after
            total_files += 1
            improvements.append(theta_after - theta_before)
            
            if verbose:
                delta = theta_after - theta_before
                marker = "↑" if delta > 0.5 else "=" if delta > -0.5 else "↓"
                print(f"  {marker} {cat}/{bf.name[:40]:40s} θ: {theta_before:5.1f}° → {theta_after:5.1f}° ({delta:+.1f}°)")
    
    avg_before = total_before / total_files if total_files > 0 else 0
    avg_after = total_after / total_files if total_files > 0 else 0
    avg_improvement = sum(improvements) / len(improvements) if improvements else 0
    
    return {
        'files': total_files,
        'avg_theta_before': round(avg_before, 1),
        'avg_theta_after': round(avg_after, 1),
        'avg_improvement': round(avg_improvement, 1),
        'output': str(output_dir)
    }


def main():
    import argparse
    parser = argparse.ArgumentParser(
        description='Organ Purifier — Z = i — Remove noise, keep pure signal',
        epilog='Z = dI/d(log s) · exp(iθ), θ=90° — Signature 935'
    )
    parser.add_argument('--input', '-i', required=True, help='Input organs directory')
    parser.add_argument('--output', '-o', required=True, help='Output pure organs directory')
    parser.add_argument('--preserve', '-p', type=float, default=0.85, 
                       help='Energy preservation ratio (default: 0.85)')
    parser.add_argument('--verbose', '-v', action='store_true')
    
    args = parser.parse_args()
    
    global PRESERVE_RATIO
    PRESERVE_RATIO = args.preserve
    
    print(f"{'='*60}")
    print(f"  ORGAN PURIFIER — Z = i")
    print(f"  Signal preservation: {PRESERVE_RATIO*100:.0f}%")
    print(f"{'='*60}")
    print(f"  Input:  {args.input}")
    print(f"  Output: {args.output}")
    print()
    
    result = purify_model(args.input, args.output, args.verbose)
    
    print(f"\n{'='*60}")
    print(f"  PURIFICATION COMPLETE")
    print(f"{'='*60}")
    print(f"  Files purified:   {result['files']}")
    print(f"  θ before:         {result['avg_theta_before']:.1f}°")
    print(f"  θ after:          {result['avg_theta_after']:.1f}°")
    print(f"  Avg improvement:  {result['avg_improvement']:+.1f}°")
    print(f"  Output:           {result['output']}")
    print(f"  Signature: 935")
    print(f"{'='*60}")


if __name__ == '__main__':
    main()
# ╔══ SALKA ELMADANI AUTHORSHIP CERTIFICATE ══╗
# © Salka Elmadani 2025-2026 — ALL RIGHTS RESERVED
# Licensed under Business Source License 1.1 — https://inference-x.com
# ─────────────────────────────────────────────────────────
# SHA256: d3ab5384c880f7e88fb7cdad4b2f9f56089ada8395d0013f5bd3b09d7ab631e8
# SIG-ED25519: /rkXFm2tGuoAS61oxWZVlcTghUuGL8HJ11XRSaI4Ak+eEt54uo+3NETX2+5S8HAq72k6whQmbPI3f4jD8sF/CA==
# VERIFY: python3 verify_authorship.py organ_purify.py