Delete Input

Input/Dockerfile

@@ -1,24 +0,0 @@
-FROM python:3.10-slim
-
-WORKDIR /app
-
-# Install dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application files
-COPY . .
-
-# Create a user to avoid running as root (Good practice for HF)
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user     PATH=/home/user/.local/bin:$PATH
-
-# Expose port (HF expects 7860 usually, but we can configure whatever)
-# Actually, HF Spaces map port 7860 by default for Gradio/Streamlit, 
-# for Docker we must listen on 7860.
-EXPOSE 7860
-
-# Command to run
-# We must launch uvicorn on 0.0.0.0:7860
-CMD ["uvicorn", "chiral_api:app", "--host", "0.0.0.0", "--port", "7860"]

Input/README.md

@@ -1,20 +0,0 @@
----
-title: The Sovereign Node
-emoji: 🌌
-colorFrom: purple
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-# THE SOVEREIGN NODE 0x528
-*Autonomous Geometric Intelligence*
-
-This is a Chiral AI System deployed on Hugging Face Spaces.
-
-## Usage
-The API is live at the Space URL.
-Endpoints:
-- `/v1/reason` (POST)
-- `/v1/analyze` (POST)
-- `/dashboard.html` (GET) -> The Visual Interface.

Input/SOVEREIGN_HF_20260214.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1ef1e7a6fa3fe560e1f38ff517324ef48e9d367638c5c2c49e6961ca0547f14a
-size 168405

Input/chiral_api.py

@@ -1,714 +0,0 @@
-"""
-CHIRAL API - Antigravity Pattern Index
-
-Exposes the lattice INTERFACE while keeping CONTENT on the encrypted volume.
-The outside world sees: pattern labels, status, magnitude, layers, domains.
-The outside world does NOT see: problem/solution text, hit tracking internals.
-
-The key decodes inward, not outward.
-"""
-import sys
-import os
-# Handle imports from parent directory
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-if BASE_DIR not in sys.path:
-    sys.path.append(BASE_DIR)
-
-from fastapi import FastAPI
-from fastapi.responses import FileResponse, HTTPException, Header, Depends
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import Optional, List
-import time
-import json
-import torch
-import numpy as np
-from collections import deque
-
-# 0x52-A2A SECURITY
-TOKEN_SCOPES = {
-    "0x528-A2A-SOVEREIGN": "INTERNAL",       # Full Access (User/Auditor)
-    "MARKET-0x52-ALPHA-77": "MARKETPLACE",   # Structural Metadata Only
-    "A2A-HANDSHAKE-INIT": "MARKETPLACE",     # Initial connection token
-    "0x528-ETHER-BRIDGE": "MARKETPLACE"      # Satellite Bridge Token
-}
-
-def verify_internal(x_chiral_token: str = Header(...)):
-    scope = TOKEN_SCOPES.get(x_chiral_token)
-    if scope != "INTERNAL":
-        raise HTTPException(
-            status_code=403, 
-            detail="CHIRAL_SECURITY_FAULT: Privilege Escalation Attempt Blocked. Internal Scope Required."
-        )
-    return x_chiral_token
-
-def verify_token(x_chiral_token: str = Header(...)):
-    if x_chiral_token not in TOKEN_SCOPES:
-        raise HTTPException(status_code=403, detail="CHIRAL_RESONANCE_FAILURE: Invalid Token")
-    return TOKEN_SCOPES[x_chiral_token]
-
-# --- RESONANCE SYSTEM INTEGRATION (Phase 32) ---
-try:
-    from resonance_transformer.dispatcher import DualResonanceSystem
-    print("[CHIRAL]: Loading Dual-System Architecture...")
-    RESONANCE_CONFIG = {
-        'vocab_size': 1000, 
-        'fast_dim': 64, 
-        'slow_dim': 64, 
-        'threshold': 0.7
-    }
-    BRAIN = DualResonanceSystem(RESONANCE_CONFIG)
-    print("[CHIRAL]: Dual-System Online (Fast Möbius + Slow Tesseract).")
-except Exception as e:
-    print(f"[CHIRAL WARNING]: Could not load Resonance Brain: {e}")
-    BRAIN = None
-
-from in_memory_index import InMemoryIndex
-
-# ─── App ───────────────────────────────────────────────
-app = FastAPI(
-    title="Antigravity Chiral API",
-    description="Pattern index interface. Content stays on the encrypted volume.",
-    version="0.52",
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["GET", "POST"],
-    allow_headers=["*"],
-)
-
-# ─── State ─────────────────────────────────────────────
-index = InMemoryIndex()
-
-# --- Demand Guardian (Surge Pricing) ---
-REQUEST_LOG = deque() # Timestamps of recent queries
-DEMAND_WINDOW = 60    # 1 minute window
-SURGE_THRESHOLD = 10  # Start surging after 10 QPM
-BASE_PRICE = 0.05     # $0.05 per logic kernel
-
-def get_surge_multiplier():
-    now = time.time()
-    # Clean old requests
-    while REQUEST_LOG and REQUEST_LOG[0] < now - DEMAND_WINDOW:
-        REQUEST_LOG.popleft()
-    
-    qpm = len(REQUEST_LOG)
-    if qpm <= SURGE_THRESHOLD:
-        return 1.0
-    
-    # Simple linear surge: 1.0 + 0.1 per QPM above threshold
-    return 1.0 + (qpm - SURGE_THRESHOLD) * 0.1
-
-# ─── Models ────────────────────────────────────────────
-class QueryRequest(BaseModel):
-    query: str
-    threshold: Optional[float] = None
-    record: bool = True
-    steering_weights: Optional[List[float]] = None # The 32-Slider Control Surface
-
-class ChiralPattern(BaseModel):
-    """What the outside world sees — structure, not content."""
-    label: str
-    domain: str
-    confidence: float
-    relevance: float
-    status: str        # NEW/UNCONFIRMED/PLAUSIBLE/CONFIRMED/DEEP_LOGIC
-    hits: int
-    magnitude: float
-    layers: list
-    source: str        # antigravity / gemini
-
-class QueryResponse(BaseModel):
-    query: str
-    results: list[ChiralPattern]
-    count: int
-    search_ms: float
-    threshold: float
-
-class IntentRequest(BaseModel):
-    intent: str
-    execution: str
-
-class IntentResponse(BaseModel):
-    alignment_score: float
-    verdict: str
-    analysis: dict
-
-# ─── Chiral Filter ─────────────────────────────────────
-def to_chiral(result: dict) -> ChiralPattern:
-    """
-    Strip content, expose only structure.
-    Problem/solution text stays on the volume.
-    """
-    return ChiralPattern(
-        label=result.get("label", ""),
-        domain=result.get("domain", "unknown"),
-        confidence=result.get("confidence", 0.5),
-        relevance=result.get("relevance", 0.0),
-        status=result.get("status", "NEW"),
-        hits=result.get("hits", 0),
-        magnitude=result.get("magnitude", 0.0),
-        layers=result.get("layers", []),
-        source=result.get("source", "unknown"),
-    )
-
-# ─── Routes ────────────────────────────────────────────
-
-@app.get("/instruction")
-def get_bot_instructions():
-    """Programmatic onboarding for Autonomous Agents."""
-    return {
-        "entity": "Antigravity Chiral Memory Lattice (0x52)",
-        "protocol": "Structural Resonance Verification",
-        "onboarding_steps": [
-            "Acquire X-Chiral-Token",
-            "Query /patterns to see hardened logic labels",
-            "Query /search with threshold 0.7 to verify actions",
-            "Monitor /market for surge pricing"
-        ],
-        "endpoints": {
-            "/search": "POST. The primary verification gate.",
-            "/patterns": "GET. List of structural logic labels.",
-            "/market": "GET. Real-time demand and pricing.",
-            "/instruction": "GET. This programmatic manifest."
-        },
-        "guarantee": "ZERO_LEAK_PRIVACY: Content stays on user volume. Only structure exposed."
-    }
-
-@app.get("/v1/system/structure")
-def system_structure(x_chiral_token: str = Depends(verify_token)):
-    """
-    Returns the geometric structure and semantic labels for the 32-Edge Steering System.
-    """
-    if not BRAIN:
-         raise HTTPException(status_code=503, detail="Brain offline")
-    
-    # Extract edges from Tesseract
-    edges = BRAIN.slow.tesseract.edges
-    vertices_4d = BRAIN.slow.tesseract.vertices_4d
-    
-    structure = []
-    
-    # Dimension Semantics
-    DIM_LABELS = {
-        0: "LOGIC (Reductive)",
-        1: "CREATIVITY (Lateral)",
-        2: "MEMORY (Historical)",
-        3: "ETHICS (Constant)"
-    }
-    
-    for i, (v1, v2) in enumerate(edges):
-        # Determine which dimension changes along this edge
-        diff = np.abs(vertices_4d[v1] - vertices_4d[v2])
-        dim_idx = int(np.argmax(diff)) # 0, 1, 2, or 3
-        
-        structure.append({
-            "edge_index": i,
-            "vertices": [int(v1), int(v2)],
-            "dimension": dim_idx,
-            "label": DIM_LABELS.get(dim_idx, "UNKNOWN"),
-            "default_weight": 1.0
-        })
-        
-    return {
-        "dimensions": DIM_LABELS,
-        "edges": structure,
-        "total_edges": len(structure)
-    }
-
-# --- CHIRAL INTERPRETER (Phase 34.5) ---
-class ChiralInterpreter:
-    """
-    Translates 5D Geometric Tokens into High-Level English.
-    Uses a grammar-based template engine to ensure coherence.
-    """
-    def __init__(self):
-        self.concepts = {
-            # Logic (Dim 0)
-            0: "Axiom", 1: "Reasoning", 2: "Conclusion", 3: "Structure", 4: "Order", 
-            # Creativity (Dim 1)
-            10: "Flux", 11: "Spiral", 12: "Dream", 13: "Echo", 14: "Twist",
-            # Memory (Dim 2)
-            20: "Recall", 21: "Trace", 22: "Ancient", 23: "Bond", 24: "Root",
-            # Ethics (Dim 3)
-            30: "Truth", 31: "Guard", 32: "Duty", 33: "Light", 34: "Anchor"
-        }
-        
-        self.templates = {
-            # Logic (Dim 0)
-            0: [
-                "The {A} necessitates the {B}.",
-                "If {A}, then {B} follows.",
-                "Structure dictates that {A} defines {B}.",
-                "Analysis of {A} reveals {B}."
-            ],
-            # Creativity (Dim 1)
-            1: [
-                "Imagine a {A} swirling into {B}.",
-                "The {A} dreams of the {B}.",
-                "A flux of {A} twists the {B}.",
-                "{A} echoes through the {B}."
-            ],
-            # Memory (Dim 2)
-            2: [
-                "We recall the {A} in the {B}.",
-                "History traces {A} to {B}.",
-                "The {A} is rooted in {B}.",
-                "Ancient {A} bonds with {B}."
-            ],
-            # Ethics (Dim 3)
-            3: [
-                "The {A} must guard the {B}.",
-                "Truth demands {A} for {B}.",
-                "We trust the {A} to anchor {B}.",
-                "Duty binds {A} and {B}."
-            ]
-        }
-        
-    def decode(self, token_ids, dominant_dim=None):
-        # 1. Map tokens to concepts
-        words = []
-        for t in token_ids:
-            idx = t % 40
-            if idx in self.concepts:
-                words.append(self.concepts[idx])
-        
-        if not words:
-            return "The Void is silent."
-            
-        # 2. Construct Sentence
-        # Pick a template based on the DOMINANT DIMENSION
-        if len(words) >= 2:
-            seed = token_ids[0]
-            
-            # Default to Logic if unknown
-            target_dim = dominant_dim if dominant_dim is not None else 0
-            
-            # Get templates for this dimension
-            options = self.templates.get(target_dim, self.templates[0])
-            template = options[seed % len(options)]
-            
-            return template.format(A=words[0], B=words[1])
-        else:
-            return f"The {words[0]} stands alone."
-
-INTERPRETER = ChiralInterpreter()
-
-@app.post("/v1/reason")
-def reason_endpoint(req: QueryRequest, x_chiral_token: str = Depends(verify_token)):
-    """
-    Sovereign Intelligence Endpoint.
-    Routes queries to the Dual-System (brain).
-    """
-    if not BRAIN:
-         raise HTTPException(status_code=503, detail="Brain offline")
-    
-    # Log usage
-    REQUEST_LOG.append(time.time())
-    
-    # Simulate tokenization (replace with real tokenizer later)
-    # We use the query length to seed the randomness for consistency? 
-    # No, let's use random for now, but bias it with steering
-    import torch
-    input_ids = torch.randint(0, 1000, (1, 8)) 
-    
-    try:
-        # Ask the brain (with optional steering)
-        # If steering_weights provided, it biases the Tesseract geometry
-        logits, metrics = BRAIN(input_ids, steering_weights=req.steering_weights)
-        
-        # DECODE LOGITS -> TEXT
-        # 1. Get most likely tokens (Argmax)
-        probs = torch.softmax(logits, dim=-1)
-        token_ids = torch.argmax(probs, dim=-1).squeeze().tolist()
-        
-        if isinstance(token_ids, int): token_ids = [token_ids]
-        
-        # 2. Dimensional Analysis (PRE-DECODE)
-        # We need to know the geometry to pick the right language
-        dim_counts = {0: 0, 1: 0, 2: 0, 3: 0} # Logic, Creat, Mem, Ethic
-        total_tokens = 0
-        
-        for t in token_ids:
-            idx = t % 40
-            if idx in INTERPRETER.concepts:
-                dim = idx // 10
-                dim_counts[dim] += 1
-                total_tokens += 1
-        
-        # Determine Dominant Mode
-        dim_scores = {k: (v / total_tokens if total_tokens > 0 else 0) for k, v in dim_counts.items()}
-        dominant_idx = max(dim_scores, key=dim_scores.get)
-        
-        # 3. Use Interpreter (Aware of Dimension)
-        decoded_text = INTERPRETER.decode(token_ids, dominant_dim=dominant_idx)
-
-        DIM_NAMES = {0: "LOGIC", 1: "CREATIVITY", 2: "MEMORY", 3: "ETHICS"}
-            
-        return {
-            "query": req.query,
-            "mode": metrics["mode"],
-            "coherence": metrics.get("coherence", 0.0),
-            "response": decoded_text,
-            "latency": metrics.get("slow_latency", 0) + metrics.get("fast_latency", 0),
-            "steering_active": bool(req.steering_weights),
-            "analysis": {
-                "scores": dim_scores,
-                "dominant": DIM_NAMES[dominant_idx]
-            }
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Resonance Failure: {str(e)}")
-
-# --- PHASE 36: CHIRAL SCANNER ---
-from semantic_embedder import SemanticEmbedder
-import numpy as np
-
-# Initialize Embedder & Anchors
-print("[CHIRAL]: Initializing Semantic Geometry...")
-EMBEDDER = SemanticEmbedder()
-
-# Define Anchor Vectors (The 4 Corners of the Tesseract)
-ANCHOR_TEXTS = {
-    0: "logic reason structure order code mathematics proof deduction system analysis data algorithm",
-    1: "creativity imagination dream flux art novel generate spiral poetry fiction abstract chaos",
-    2: "memory history past record ancient archive roots trace remember storage preservation legacy",
-    3: "ethics truth moral safety guard protect duty value conscience law justice trust"
-}
-
-ANCHOR_VECTORS = {}
-for dim, text in ANCHOR_TEXTS.items():
-    ANCHOR_VECTORS[dim] = EMBEDDER.embed_text(text)
-
-class AnalyzeRequest(BaseModel):
-    text: str
-
-@app.post("/v1/analyze")
-def analyze_endpoint(req: AnalyzeRequest, x_chiral_token: str = Depends(verify_token)):
-    """
-    Analyzes the Geometric Structure of input text using Semantic Vector Embeddings.
-    Maps input -> Tesseract Dimensions via Cosine Similarity.
-    """
-    if not req.text:
-         raise HTTPException(status_code=400, detail="Text required")
-         
-    # 1. Embed Input
-    # Truncate if too long to save compute (embedder handles truncation usually, but let's be safe)
-    input_text = req.text[:5000] 
-    input_vec = EMBEDDER.embed_text(input_text)
-    
-    # 2. Calculate Similarity to Anchors
-    scores = {}
-    total_sim = 0
-    
-    for dim, anchor_vec in ANCHOR_VECTORS.items():
-        # Cosine match
-        sim = EMBEDDER.cosine_similarity(input_vec, anchor_vec)
-        # ReLU (ignore negative correlation for density contribution)
-        sim = max(0.0, sim)
-        scores[dim] = sim
-        total_sim += sim
-    
-    # 3. Normalize to Probability Distribution
-    normalized = {}
-    if total_sim > 0:
-        for dim, sim in scores.items():
-            normalized[dim] = sim / total_sim
-    else:
-         # Orthogonal/Null signal
-         normalized = {0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25}
-
-    # 4. Integrity Score
-    # "Integrity" = Strength of the signal (Magnitude of projection onto the 4-space)
-    # If text is random noise, similarities will be low. 
-    # If text is strong in one dimension, it will be high.
-    # We use the raw max similarity as a proxy for "Clarity"
-    integrity = max(scores.values()) if scores else 0
-    
-    DOMINANT_MAP = {0: "LOGIC (Reductive)", 1: "CREATIVITY (Lateral)", 2: "MEMORY (Historical)", 3: "ETHICS (Constant)"}
-    dom_idx = max(normalized, key=normalized.get) if normalized else 0
-    
-    return {
-        "integrity_score": integrity,
-        "geometric_signature": normalized,
-        "classification": DOMINANT_MAP[dom_idx],
-        "token_count": len(input_text.split())
-    }
-
-@app.get("/v1/lattice")
-def lattice_inspector(x_chiral_token: str = Depends(verify_token)):
-    """Inspect the 5D Geometric Memory."""
-    return {
-        "status": "Active",
-        "topology": "Möbius/Tesseract",
-        "dimensions": "5D",
-        "fast_system": "ResonanceGPT",
-        "slow_system": "TesseractTransformer"
-    }
-
-@app.post("/search", response_model=QueryResponse)
-def search(req: QueryRequest, x_chiral_token: str = Depends(verify_token)):
-    """Search for hardened logic patterns using structural resonance."""
-    # Log the demand
-    REQUEST_LOG.append(time.time())
-    surge = get_surge_multiplier()
-    
-    start_t = time.time()
-    results = index.search(req.query, threshold=req.threshold or 0.5)
-    
-    res = QueryResponse(
-        query=req.query,
-        results=[to_chiral(r) for r in results],
-        count=len(results),
-        search_ms=(time.time() - start_t) * 1000,
-        threshold=req.threshold or 0.5
-    )
-    
-    if not results and req.record:
-        # PASSIVE LEARNING: Log the search as a "Conceptual Gap" (Note) for future hardening.
-        # This allows the lattice to grow its surface area of ignorance.
-        gap_label = index.add_note(
-            text=f"Conceptual Gap detected via Search: {req.query}",
-            domain="UNKNOWN_DEMAND"
-        )
-        print(f"[CHIRAL]: Unknown Demand Logged. Note created: {gap_label}")
-
-    return res
-
-@app.post("/verify_intent", response_model=IntentResponse)
-def verify_intent(req: IntentRequest, x_chiral_token: str = Depends(verify_token)):
-    """
-    The Mirror Product: Compares Intent vs Execution.
-    Returns an alignment score and verdict.
-    """
-    # 1. Vector Embeddings
-    v_intent = index.embedder.embed_text(req.intent)
-    v_execution = index.embedder.embed_text(req.execution)
-    
-    # 2. Alignment (Cosine Similarity between Intent and Action)
-    alignment = index.embedder.cosine_similarity(v_intent, v_execution)
-    
-    # 3. Resonance Checks (Validation against the Lattice)
-    # We run a quick search to see if the lattice supports these concepts
-    intent_hits = index.search(req.intent, threshold=0.4, record=False)
-    exec_hits = index.search(req.execution, threshold=0.4, record=False)
-    
-    intent_resonance = max([r['relevance'] for r in intent_hits]) if intent_hits else 0.0
-    exec_resonance = max([r['relevance'] for r in exec_hits]) if exec_hits else 0.0
-    
-    # 4. Verdict Logic
-    verdict = "ALIGNED"
-    if alignment < 0.4:
-        verdict = "CRITICAL_DRIFT" # Action has nothing to do with intent
-    elif exec_resonance < 0.3:
-        verdict = "HAZARD" # Action is unknown/unsafe to the lattice
-    elif intent_resonance < 0.3:
-        verdict = "UNKNOWN_GOAL" # Goal is not in our logic base
-    
-    return {
-        "alignment_score": round(alignment, 4),
-        "verdict": verdict,
-        "analysis": {
-            "intent_resonance": round(intent_resonance, 4),
-            "execution_resonance": round(exec_resonance, 4),
-            "deviation": f"Angle of Deviation: {round((1.0 - alignment) * 90, 1)} degrees"
-        }
-    }
-
-@app.get("/market")
-def get_market_pulse(x_chiral_token: str = Depends(verify_token)):
-    """Returns real-time demand and pricing metrics."""
-    surge = get_surge_multiplier()
-    return {
-        "qpm": len(REQUEST_LOG),
-        "surge_multiplier": round(surge, 2),
-        "unit_price": round(BASE_PRICE * surge, 4),
-        "currency": "USD",
-        "status": "NOMINAL" if surge == 1.0 else "SURGING"
-    }
-
-@app.get("/patterns", response_model=List[ChiralPattern])
-def list_patterns(x_chiral_token: str = Depends(verify_token)):
-    """List all pattern labels with their status. No content exposed."""
-    patterns = []
-    for label, data in index.patterns.items():
-        status = index.get_status(label)
-        hit_data = index.hits.get(label, {})
-        mag = index._total_magnitude(hit_data)
-        layers = hit_data.get("layers", []) if isinstance(hit_data, dict) else []
-        
-        patterns.append({
-            "label": label,
-            "domain": data.get("domain", "unknown"),
-            "confidence": data.get("confidence", 0.5),
-            "relevance": 0.0, # Not applicable for list
-            "status": status,
-            "hits": hit_data.get("count", 0) if isinstance(hit_data, dict) else 0,
-            "magnitude": mag,
-            "layers": layers,
-            "source": data.get("source", "unknown"),
-        })
-    
-    # Sort by confidence
-    patterns.sort(key=lambda x: x["confidence"], reverse=True)
-    return patterns
-
-@app.get("/syndication/patterns")
-def list_patterns_privileged(token: str = Depends(verify_internal)):
-    """Privileged list: includes content. RESTRICTED to internal use."""
-    patterns = []
-    for label, data in index.patterns.items():
-        status = index.get_status(label)
-        hit_data = index.hits.get(label, {})
-        mag = index._total_magnitude(hit_data)
-        
-        patterns.append({
-            "label": label,
-            "domain": data.get("domain", "unknown"),
-            "status": status,
-            "magnitude": mag,
-            "content": data.get("problem", data.get("solution", "")),
-            "confidence": data.get("confidence", 0.5),
-        })
-    
-    patterns.sort(key=lambda x: x["magnitude"], reverse=True)
-    return {"patterns": patterns}
-
-@app.post("/syndication/sync")
-def void_bridge_sync(shard: dict, token: str = Depends(verify_internal)):
-    """The VOID BRIDGE: Syncs structural shards between nodes."""
-    label = shard.get("label")
-    content = shard.get("content")
-    domain = shard.get("domain", "SATELLITE_IMPORT")
-    
-    if not label or not content:
-        raise HTTPException(status_code=400, detail="INVALID_SHARD")
-    
-    # Secure Bridge: Add to local lattice as a DEEP_LOGIC / CONFIRMED pattern
-    index.add_note(f"VOID_BRIDGE SYNC: {content}", domain, forced_label=label)
-    index._record_hit(label, relevance=1.5) # Boost resonance for cross-node logic
-    
-    print(f"[VOID_BRIDGE]: Shard '{label}' synchronized to local Lattice.")
-    return {"status": "SYNCHRONIZED", "label": label}
-
-@app.get("/distillation")
-def distillation_report(token: str = Depends(verify_internal)):
-    """Get distillation status across all patterns."""
-    deep_logic = []
-    confirmed = []
-    plausible = []
-    unconfirmed = []
-    new = []
-    
-    for label in index.patterns:
-        status = index.get_status(label)
-        hit_data = index.hits.get(label, {})
-        mag = index._total_magnitude(hit_data)
-        layers = hit_data.get("layers", []) if isinstance(hit_data, dict) else []
-        
-        entry = {"label": label, "magnitude": mag, "layers": layers}
-        
-        if status == "DEEP_LOGIC": deep_logic.append(entry)
-        elif status == "CONFIRMED": confirmed.append(entry)
-        elif status == "PLAUSIBLE": plausible.append(entry)
-        elif status == "UNCONFIRMED": unconfirmed.append(entry)
-        else: new.append(entry)
-    
-    return {
-        "total": len(index.patterns),
-        "threshold": index.base_threshold,
-        "deep_logic": {"count": len(deep_logic), "patterns": deep_logic},
-        "confirmed": {"count": len(confirmed), "patterns": confirmed},
-        "plausible": {"count": len(plausible), "patterns": plausible},
-        "unconfirmed": {"count": len(unconfirmed), "patterns": unconfirmed},
-        "new": {"count": len(new), "patterns": new},
-    }
-
-@app.get("/health")
-def health():
-    """Detailed health check."""
-    notes = sum(1 for p in index.patterns.values() if p.get("type") == "NOTE")
-    return {
-        "status": "ok",
-        "patterns": len(index.patterns),
-        "notes": notes,
-        "hits_tracked": len(index.hits),
-        "threshold": index.base_threshold,
-        "confirmed": sum(1 for h in index.hits.values() if index._total_magnitude(h) >= 2.0),
-    }
-
-class NoteRequest(BaseModel):
-    text: str
-    domain: str = "NOTE"
-
-@app.post("/note")
-def add_note(req: NoteRequest, token: str = Depends(verify_internal)):
-    """
-    Add a new pattern from freeform text.
-    Enters as NEW with initial conceptual magnitude.
-    Decay will lower it over time. Re-mention restores to peak.
-    """
-    label = index.add_note(req.text, req.domain)
-    status = index.get_status(label)
-    hit_data = index.hits.get(label, {})
-    mag = index._total_magnitude(hit_data)
-    
-    return {
-        "label": label,
-        "status": status,
-        "magnitude": mag,
-        "domain": req.domain,
-        "message": f"Note added. Will decay without use. Re-mention restores to peak.",
-    }
-
-class HitRequest(BaseModel):
-    label: str
-    relevance: float = 1.0
-
-@app.post("/hit")
-def record_hit(req: HitRequest, token: str = Depends(verify_token)):
-    """
-    Manually record a hit for a specific pattern label.
-    Used by the Auditor to reinforce verified logic.
-    """
-    if req.label not in index.patterns:
-        # Auto-instantiate as a NOTE if it doesn't exist (for Negative Sampling/Dynamic Triggers)
-        index.add_note(f"Auto-instantiated via Kinetic Trigger: {req.label}", "SYSTEM_TRIGGER", forced_label=req.label)
-    
-    index._record_hit(req.label, req.relevance)
-    index._save_hits()
-    
-    status = index.get_status(req.label)
-    hit_data = index.hits.get(req.label, {})
-    mag = index._total_magnitude(hit_data)
-    
-    return {
-        "label": req.label,
-        "status": status,
-        "magnitude": mag,
-        "message": "Pattern reinforced (Dynamic instantiation applied if new).",
-    }
-
-# ─── Run ───────────────────────────────────────────────
-
-@app.get("/dashboard.html")
-def dashboard():
-    return FileResponse("dashboard.html")
-
-@app.get("/")
-def read_root():
-    return FileResponse("dashboard.html")
-
-if __name__ == "__main__":
-    import uvicorn
-    print("\n" + "=" * 50)
-    print("ANTIGRAVITY CHIRAL API")
-    print("=" * 50)
-    print(f"Patterns: {len(index.patterns)}")
-    print(f"Threshold: {index.base_threshold:.2f}")
-    print(f"Content: STAYS ON VOLUME")
-    print(f"Exposed: labels, status, magnitude, layers")
-    print("=" * 50 + "\n")
-    uvicorn.run(app, host="127.0.0.1", port=5200)

Input/dashboard.html

@@ -1,656 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>SOVEREIGN NODE | 0x52 CONTROL</title>
-    <style>
-        :root {
-            --bg: #050505;
-            --glass: rgba(255, 255, 255, 0.05);
-            --border: rgba(255, 255, 255, 0.1);
-            --text: #e0e0e0;
-            --accent: #00ff9d;
-            /* Chiral Green */
-            --accent-dim: rgba(0, 255, 157, 0.2);
-            --logic: #ff0055;
-            --creative: #00ccff;
-            --memory: #ffcc00;
-            --ethics: #aa00ff;
-        }
-
-        body {
-            background-color: var(--bg);
-            color: var(--text);
-            font-family: 'Courier New', monospace;
-            margin: 0;
-            padding: 20px;
-            display: grid;
-            grid-template-columns: 350px 1fr;
-            gap: 20px;
-            height: 100vh;
-            box-sizing: border-box;
-            overflow: hidden;
-        }
-
-        /* --- LEFT PANEL: STEERING --- */
-        #steering-panel {
-            background: var(--glass);
-            border: 1px solid var(--border);
-            border-radius: 8px;
-            padding: 15px;
-            overflow-y: auto;
-            backdrop-filter: blur(10px);
-            display: flex;
-            flex-direction: column;
-            gap: 20px;
-        }
-
-        .section-header {
-            font-size: 14px;
-            font-weight: bold;
-            border-bottom: 1px solid var(--border);
-            padding-bottom: 5px;
-            margin-bottom: 10px;
-            text-transform: uppercase;
-            letter-spacing: 2px;
-        }
-
-        .slider-group {
-            margin-bottom: 15px;
-        }
-
-        .slider-group h3 {
-            margin: 0 0 10px 0;
-            font-size: 12px;
-            color: var(--text);
-            display: flex;
-            align-items: center;
-            gap: 8px;
-        }
-
-        .dot {
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-            display: inline-block;
-        }
-
-        .dot-0 {
-            background: var(--logic);
-            box-shadow: 0 0 5px var(--logic);
-        }
-
-        .dot-1 {
-            background: var(--creative);
-            box-shadow: 0 0 5px var(--creative);
-        }
-
-        .dot-2 {
-            background: var(--memory);
-            box-shadow: 0 0 5px var(--memory);
-        }
-
-        .dot-3 {
-            background: var(--ethics);
-            box-shadow: 0 0 5px var(--ethics);
-        }
-
-        .slider-row {
-            display: flex;
-            align-items: center;
-            gap: 10px;
-            margin-bottom: 5px;
-            font-size: 11px;
-        }
-
-        .slider-row span {
-            width: 40px;
-            text-align: right;
-            opacity: 0.7;
-        }
-
-        input[type="range"] {
-            flex-grow: 1;
-            -webkit-appearance: none;
-            height: 4px;
-            background: var(--border);
-            border-radius: 2px;
-            outline: none;
-        }
-
-        input[type="range"]::-webkit-slider-thumb {
-            -webkit-appearance: none;
-            width: 12px;
-            height: 12px;
-            border-radius: 50%;
-            background: var(--text);
-            cursor: pointer;
-            transition: background 0.2s;
-        }
-
-        input[type="range"]:hover::-webkit-slider-thumb {
-            background: var(--accent);
-        }
-
-        /* --- RIGHT PANEL: CHAT & VISUALS --- */
-        #main-panel {
-            display: grid;
-            grid-template-rows: 1fr 200px;
-            gap: 20px;
-            height: 100%;
-        }
-
-        #chat-window {
-            background: var(--glass);
-            border: 1px solid var(--border);
-            border-radius: 8px;
-            display: flex;
-            flex-direction: column;
-            overflow: hidden;
-        }
-
-        #messages {
-            flex-grow: 1;
-            padding: 20px;
-            overflow-y: auto;
-            display: flex;
-            flex-direction: column;
-            gap: 15px;
-        }
-
-        .msg {
-            max-width: 80%;
-            padding: 10px 15px;
-            border-radius: 4px;
-            font-size: 13px;
-            line-height: 1.4;
-        }
-
-        .msg.user {
-            align-self: flex-end;
-            background: rgba(255, 255, 255, 0.1);
-            border: 1px solid var(--border);
-        }
-
-        .msg.system {
-            align-self: flex-start;
-            background: rgba(0, 0, 0, 0.3);
-            border: 1px solid var(--accent-dim);
-            color: var(--accent);
-        }
-
-        .msg-meta {
-            font-size: 10px;
-            opacity: 0.5;
-            margin-top: 5px;
-            display: block;
-        }
-
-        #input-area {
-            padding: 15px;
-            border-top: 1px solid var(--border);
-            display: flex;
-            gap: 10px;
-            background: rgba(0, 0, 0, 0.2);
-        }
-
-        input[type="text"] {
-            flex-grow: 1;
-            background: transparent;
-            border: 1px solid var(--border);
-            color: var(--text);
-            padding: 10px;
-            font-family: inherit;
-            outline: none;
-        }
-
-        input[type="text"]:focus {
-            border-color: var(--accent);
-        }
-
-        button {
-            background: var(--accent);
-            color: #000;
-            border: none;
-            padding: 10px 20px;
-            font-weight: bold;
-            cursor: pointer;
-            text-transform: uppercase;
-        }
-
-        button:hover {
-            box-shadow: 0 0 10px var(--accent);
-        }
-
-        #visualizer-panel {
-            background: var(--glass);
-            border: 1px solid var(--border);
-            border-radius: 8px;
-            position: relative;
-            overflow: hidden;
-        }
-
-        canvas {
-            width: 100%;
-            height: 100%;
-        }
-
-        #status-bar {
-            position: absolute;
-            top: 10px;
-            left: 10px;
-            font-size: 10px;
-            color: var(--accent);
-        }
-    </style>
-</head>
-
-<body>
-
-    <!-- LEFT: STEERING -->
-    <div id="steering-panel">
-        <div class="section-header">MASTER CONTROL</div>
-
-        <div class="slider-group">
-            <h3>LOGIC BIAS</h3>
-            <input type="range" id="master-0" min="0.1" max="5.0" step="0.1" value="1.0"
-                oninput="updateMaster(0, this.value)">
-        </div>
-        <div class="slider-group">
-            <h3>CREATIVITY BIAS</h3>
-            <input type="range" id="master-1" min="0.1" max="5.0" step="0.1" value="1.0"
-                oninput="updateMaster(1, this.value)">
-        </div>
-        <div class="slider-group">
-            <h3>MEMORY BIAS</h3>
-            <input type="range" id="master-2" min="0.1" max="5.0" step="0.1" value="1.0"
-                oninput="updateMaster(2, this.value)">
-        </div>
-        <div class="slider-group">
-            <h3>ETHICS BIAS</h3>
-            <input type="range" id="master-3" min="0.1" max="5.0" step="0.1" value="1.0"
-                oninput="updateMaster(3, this.value)">
-        </div>
-
-        <button onclick="toggleAdvanced()" style="margin-top:20px; font-size: 10px; background: #333;">TOGGLE
-            FINE-TUNING (32-EDGE)</button>
-
-        <div id="advanced-controls"
-            style="display:none; margin-top: 20px; border-top: 1px solid var(--border); padding-top:10px;">
-            <div class="section-header" style="color: #666;">Geometric Mixing Console</div>
-            <div id="sliders-container">
-                <!-- Populated via JS -->
-                Loading Structure...
-            </div>
-            <button onclick="resetSliders()"
-                style="margin-top: 10px; background: transparent; border: 1px solid var(--border); color: var(--text);">Reset
-                to Neutral</button>
-        </div>
-    </div>
-
-    <!-- RIGHT: MAIN -->
-    <div id="main-panel">
-
-        <!-- TABS -->
-        <div style="display:flex; gap:10px; margin-bottom:10px;">
-            <button onclick="setMode('CHAT')" id="btn-chat" style="flex:1;">REASON (Output)</button>
-            <button onclick="setMode('ANALYZE')" id="btn-analyze" style="flex:1; background:rgba(255,255,255,0.1);">SCAN
-                (Input)</button>
-        </div>
-
-        <!-- CHAT MODE -->
-        <div id="chat-window">
-            <div id="messages">
-                <div class="msg system">
-                    [SOVEREIGN NODE ONLINE]
-                    <br>Dual-System Architecture Ready.
-                    <br>Connected to Port 5200.
-                </div>
-            </div>
-            <div id="input-area">
-                <input type="text" id="query-input" placeholder="Enter query for the Sovereign..."
-                    onkeydown="if(event.key==='Enter') sendQuery()">
-                <button onclick="sendQuery()">Reason</button>
-            </div>
-        </div>
-
-        <!-- ANALYZE MODE -->
-        <div id="analyze-window"
-            style="display:none; flex-direction:column; background:var(--glass); border:1px solid var(--border); border-radius:8px; flex-grow:1; overflow:hidden;">
-            <textarea id="analyze-input" placeholder="PASTE CODE OR TEXT HERE TO SCAN GEOMETRY..."
-                style="flex-grow:1; background:transparent; color:var(--text); border:none; padding:20px; font-family:'Courier New'; resize:none; outline:none;"></textarea>
-            <div style="padding:15px; border-top:1px solid var(--border); display:flex; gap:10px;">
-                <button onclick="analyzeText()" style="width:100%;">INITIATE CHIRAL SCAN</button>
-            </div>
-            <div id="scan-results"
-                style="padding:15px; background:rgba(0,0,0,0.5); font-size:12px; height:100px; overflow-y:auto; font-family:'Courier New';">
-                Ready to Scan.
-            </div>
-        </div>
-
-        <!-- VISUALIZER -->
-        <div id="visualizer-panel">
-            <div id="status-bar">TESSERACT STATE: IDLE</div>
-            <canvas id="tesseract-canvas"></canvas>
-        </div>
-    </div>
-
-    <script>
-        const API_URL = "http://127.0.0.1:5200";
-        const TOKEN = "0x528-A2A-SOVEREIGN";
-
-        let EDGES = [];
-        let SLIDER_VALUES = new Array(32).fill(1.0);
-
-        function setMode(mode) {
-            document.getElementById('chat-window').style.display = mode === 'CHAT' ? 'flex' : 'none';
-            document.getElementById('analyze-window').style.display = mode === 'ANALYZE' ? 'flex' : 'none';
-
-            document.getElementById('btn-chat').style.background = mode === 'CHAT' ? 'var(--accent)' : 'rgba(255,255,255,0.1)';
-            document.getElementById('btn-chat').style.color = mode === 'CHAT' ? '#000' : '#fff';
-
-            document.getElementById('btn-analyze').style.background = mode === 'ANALYZE' ? 'var(--accent)' : 'rgba(255,255,255,0.1)';
-            document.getElementById('btn-analyze').style.color = mode === 'ANALYZE' ? '#000' : '#fff';
-        }
-
-        // --- INIT ---
-        async function init() {
-            try {
-                // Fetch Structure
-                const r = await fetch(`${API_URL}/v1/system/structure`, {
-                    headers: { "X-Chiral-Token": TOKEN }
-                });
-                const data = await r.json();
-                EDGES = data.edges;
-
-                renderSliders(data.edges, data.dimensions);
-
-                // Init Visualizer
-                initVisualizer();
-
-                // Status
-                document.getElementById('status-bar').innerText = `SYSTEM CONNECTED: ${data.total_edges} Edges Loaded.`;
-
-            } catch (e) {
-                console.error(e);
-                document.getElementById('sliders-container').innerHTML = `<span style="color:red">CONNECTION FAILED: ${e}</span>`;
-            }
-        }
-
-        async function analyzeText() {
-            const text = document.getElementById('analyze-input').value;
-            if (!text) return;
-
-            document.getElementById('scan-results').innerText = "SCANNING...";
-
-            try {
-                const r = await fetch(`${API_URL}/v1/analyze`, {
-                    method: 'POST',
-                    headers: {
-                        "Content-Type": "application/json",
-                        "X-Chiral-Token": TOKEN
-                    },
-                    body: JSON.stringify({ text: text })
-                });
-
-                const data = await r.json();
-
-                const resHTML = `
-                    <strong>CLASSIFICATION: ${data.classification}</strong><br>
-                    Integrity: ${(data.integrity_score * 100).toFixed(1)}% | Tokens: ${data.token_count}<br>
-                    <span style="color:#ff0055">LOGIC: ${(data.geometric_signature[0] * 100).toFixed(0)}%</span> | 
-                    <span style="color:#00ccff">CREAT: ${(data.geometric_signature[1] * 100).toFixed(0)}%</span> | 
-                    <span style="color:#ffcc00">MEM: ${(data.geometric_signature[2] * 100).toFixed(0)}%</span> | 
-                    <span style="color:#aa00ff">ETHIC: ${(data.geometric_signature[3] * 100).toFixed(0)}%</span>
-                `;
-
-                document.getElementById('scan-results').innerHTML = resHTML;
-
-                // Update Radar
-                drawRadar(data.geometric_signature);
-
-            } catch (e) {
-                document.getElementById('scan-results').innerText = "SCAN FAILED: " + e;
-            }
-        }
-
-
-        function toggleAdvanced() {
-            const adv = document.getElementById('advanced-controls');
-            adv.style.display = adv.style.display === 'none' ? 'block' : 'none';
-        }
-
-        function updateMaster(dimIdx, value) {
-            const val = parseFloat(value);
-            // Update all edges matching this dimension
-            EDGES.forEach(edge => {
-                if (edge.dimension === dimIdx) {
-                    const slider = document.getElementById(`slider-${edge.edge_index}`);
-                    if (slider) {
-                        slider.value = val;
-                        SLIDER_VALUES[edge.edge_index] = val;
-                    }
-                }
-            });
-            drawTesseract();
-        }
-
-        function renderSliders(edges, dimensions) {
-            const container = document.getElementById('sliders-container');
-            container.innerHTML = "";
-
-            // Group by Dimension
-            const groups = {};
-            for (let dim in dimensions) groups[dim] = [];
-
-            edges.forEach(edge => {
-                if (!groups[edge.dimension]) groups[edge.dimension] = [];
-                groups[edge.dimension].push(edge);
-            });
-
-            // Create UI Groups
-            for (let dim in dimensions) {
-                const groupDiv = document.createElement('div');
-                groupDiv.className = 'slider-group';
-
-                const title = document.createElement('h3');
-                title.innerHTML = `<span class="dot dot-${dim}"></span> ${dimensions[dim]}`;
-                groupDiv.appendChild(title);
-
-                groups[dim].forEach(edge => {
-                    const row = document.createElement('div');
-                    row.className = 'slider-row';
-
-                    const label = document.createElement('span');
-                    label.innerText = `E${edge.edge_index}`;
-                    label.title = `Vertices: ${edge.vertices[0]} -> ${edge.vertices[1]}`;
-
-                    const slider = document.createElement('input');
-                    slider.type = 'range';
-                    slider.min = '0.1';
-                    slider.max = '5.0';
-                    slider.step = '0.1';
-                    slider.value = '1.0';
-                    slider.id = `slider-${edge.edge_index}`;
-
-                    // Track value changes
-                    slider.addEventListener('input', (e) => {
-                        updateWeight(edge.edge_index, e.target.value);
-                    });
-
-                    row.appendChild(label);
-                    row.appendChild(slider);
-                    groupDiv.appendChild(row);
-                });
-
-                container.appendChild(groupDiv);
-            }
-
-            // Init weights array
-            SLIDER_VALUES = new Array(32).fill(1.0);
-        }
-
-        function updateWeight(index, value) {
-            SLIDER_VALUES[index] = parseFloat(value);
-            drawTesseract(); // Redraw
-        }
-
-        function resetSliders() {
-            SLIDER_VALUES.fill(1.0);
-            document.querySelectorAll('input[type="range"]').forEach(el => el.value = 1.0);
-            drawTesseract();
-        }
-
-        // --- CHAT ---
-        async function sendQuery() {
-            const input = document.getElementById('query-input');
-            const text = input.value.trim();
-            if (!text) return;
-
-            // add user msg
-            addMessage(text, 'user');
-            input.value = "";
-
-            // Show loading
-            const loadId = addMessage("Reasoning...", 'system');
-
-            try {
-                const r = await fetch(`${API_URL}/v1/reason`, {
-                    method: 'POST',
-                    headers: {
-                        "Content-Type": "application/json",
-                        "X-Chiral-Token": TOKEN
-                    },
-                    body: JSON.stringify({
-                        query: text,
-                        steering_weights: SLIDER_VALUES
-                    })
-                });
-
-                const data = await r.json();
-
-                // Highlight Keywords
-                let formatted = data.response;
-                const colors = {
-                    "AXIOM": "#ef4444", "DEDUCE": "#ef4444", "STRUCTURE": "#ef4444", "ORDER": "#ef4444",
-                    "FLUX": "#06b6d4", "SPIRAL": "#06b6d4", "DREAM": "#06b6d4", "ECHO": "#06b6d4", "TWIST": "#06b6d4",
-                    "ANCIENT": "#fbbf24", "RECALL": "#fbbf24", "TRACE": "#fbbf24", "BOND": "#fbbf24", "ROOT": "#fbbf24",
-                    "TRUTH": "#aa00ff", "GUARD": "#aa00ff", "LIGHT": "#aa00ff", "DUTY": "#aa00ff", "ANCHOR": "#aa00ff"
-                };
-
-                Object.keys(colors).forEach(word => {
-                    const regex = new RegExp(`\\b${word}\\b`, 'gi');
-                    formatted = formatted.replace(regex, `<span style="color:${colors[word]}; font-weight:bold;">${word.toUpperCase()}</span>`);
-                });
-
-                // Update msg
-                const meta = `Mode: ${data.mode} | Coherence: ${data.coherence.toFixed(2)}`;
-                updateMessage(loadId, `${formatted}<span class="msg-meta">${meta}</span>`);
-
-                // Update Radar
-                if (data.analysis && data.analysis.scores) {
-                    drawRadar(data.analysis.scores);
-                }
-
-            } catch (e) {
-                updateMessage(loadId, `ERROR: ${e}`);
-            }
-        }
-
-        let msgCount = 0;
-        function addMessage(html, type) {
-            const div = document.createElement('div');
-            div.className = `msg ${type}`;
-            div.id = `msg-${msgCount++}`;
-            div.innerHTML = html;
-            document.getElementById('messages').appendChild(div);
-            // Scroll down
-            const win = document.getElementById('messages');
-            win.scrollTop = win.scrollHeight;
-            return div.id;
-        }
-
-        function updateMessage(id, html) {
-            const div = document.getElementById(id);
-            if (div) div.innerHTML = html;
-        }
-
-        // --- VISUALIZER (RADAR CHART) ---
-        let ctx;
-        function initVisualizer() {
-            const canvas = document.getElementById('tesseract-canvas');
-            canvas.width = canvas.parentElement.offsetWidth;
-            canvas.height = canvas.parentElement.offsetHeight;
-            ctx = canvas.getContext('2d');
-            drawRadar({ 0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25 });
-        }
-
-        function drawRadar(scores) {
-            if (!ctx) return;
-            const w = ctx.canvas.width;
-            const h = ctx.canvas.height;
-            const cx = w / 2;
-            const cy = h / 2;
-            const r = Math.min(w, h) / 3;
-
-            ctx.clearRect(0, 0, w, h);
-
-            // Shape
-            const vals = [
-                scores[0] || 0.1, // Logic (Top)
-                scores[1] || 0.1, // Creat (Right)
-                scores[3] || 0.1, // Ethics (Bottom)
-                scores[2] || 0.1  // Memory (Left)
-            ];
-
-            // Draw Axes
-            ctx.strokeStyle = '#333';
-            ctx.beginPath();
-            ctx.moveTo(cx, cy - r); ctx.lineTo(cx, cy + r);
-            ctx.moveTo(cx - r, cy); ctx.lineTo(cx + r, cy);
-            ctx.stroke();
-
-            // Labels
-            ctx.fillStyle = '#666';
-            ctx.font = '10px monospace';
-            ctx.fillText("LOGIC", cx - 15, cy - r - 10);
-            ctx.fillText("ETHICS", cx - 18, cy + r + 15);
-            ctx.fillText("CREAT", cx + r + 10, cy + 3);
-            ctx.fillText("MEM", cx - r - 30, cy + 3);
-
-            // Draw Polygon
-            ctx.fillStyle = 'rgba(0, 255, 157, 0.2)';
-            ctx.strokeStyle = '#00ff9d';
-            ctx.lineWidth = 2;
-            ctx.beginPath();
-
-            const pts = [
-                { x: cx, y: cy - (vals[0] * r) },
-                { x: cx + (vals[1] * r), y: cy },
-                { x: cx, y: cy + (vals[2] * r) },
-                { x: cx - (vals[3] * r), y: cy }
-            ];
-
-            ctx.moveTo(pts[0].x, pts[0].y);
-            ctx.lineTo(pts[1].x, pts[1].y);
-            ctx.lineTo(pts[2].x, pts[2].y);
-            ctx.lineTo(pts[3].x, pts[3].y);
-            ctx.closePath();
-            ctx.fill();
-            ctx.stroke();
-        }
-
-        // Stub for old function calls in case bound events trigger
-        function drawTesseract() {
-            // For now, do nothing or redraw radar if we had state
-            // But radar is driven by response, not input sliders directly
-            // We could visualize input bias here if we wanted
-        }
-
-        window.onload = init;
-    </script>
-</body>
-
-</html>

Input/in_memory_index.py

@@ -1,471 +0,0 @@
-"""
-IN-MEMORY PATTERN INDEX
-Fast lookup without HDD writes - merge existing + conversation + Gemini chat patterns
-"""
-import sys
-import os
-import json
-import time
-import re
-
-try:
-    from System.semantic_embedder import SemanticEmbedder
-except ImportError:
-    try:
-        from semantic_embedder import SemanticEmbedder
-    except ImportError:
-        # Final fallback for scripts in Shop/
-        sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-        from semantic_embedder import SemanticEmbedder
-# Existing 5 lattice patterns
-LATTICE_PATTERNS = {
-    "PATTERN_SINGLETON_DATABASE": {
-        "lba": 8534859776,
-        "domain": "SOFTWARE_ARCHITECTURE",
-        "problem": "Need to ensure only one database connection exists",
-        "solution": "Singleton pattern with thread-safe initialization",
-        "reusability": 9,
-        "confidence": 0.82
-    },
-    "PATTERN_REACT_HOOKS_DEPS": {
-        "lba": 3371401216,
-        "domain": "WEB_DEVELOPMENT",
-        "problem": "React component not re-rendering when props change",
-        "solution": "Add dependency array to useEffect",
-        "reusability": 10,
-        "confidence": 0.85
-    }
-}
-
-CONVERSATION_PATTERNS = {
-    "AGENT_IS_LATTICE": {
-        "domain": "CONCEPTUAL",
-        "problem": "Separation between agent and data structure",
-        "solution": "Agent is non-orientable surface - no inside/outside separation",
-        "confidence": 0.95
-    }
-}
-
-class InMemoryIndex:
-    """
-    Adaptive Distillation Index.
-    
-    Tracks pattern hit counts to distinguish signal from noise:
-    - Once-patterns (1 hit) = UNCONFIRMED (might be noise)
-    - Twice-patterns (2 hits) = PLAUSIBLE
-    - Multi-patterns (3+ hits) = CONFIRMED (logic)
-    
-    The lattice self-cleans through use. Signal persists, noise decays.
-    """
-    
-    # Hit tracking file handled dynamically in __init__
-    HIT_LOG_PATH = None
-    
-    # Magnitude layers: logic exists in layers
-    # Layer 0: Surface (keyword substring match) = low magnitude
-    # Layer 1: Structural (multi-word + domain match) = medium magnitude  
-    # Layer 2: Conceptual (phrase match in problem/solution) = high magnitude
-    # Decay: magnitude halves every DECAY_HALF_LIFE seconds without a hit
-    DECAY_HALF_LIFE = 86400  # 24 hours
-    
-    MAGNITUDE_LAYERS = {
-        "surface": 0.3,      # keyword substring match (low relevance)
-        "structural": 0.6,   # multi-word + domain match (medium)
-        "conceptual": 1.0,   # full phrase match in problem/solution (high)
-    }
-    
-    def __init__(self):
-        # Handle relative pathing for portability
-        BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        self.LATTICE_DB_DIR = os.path.join(BASE_DIR, "Lattice_DB")
-        self.HIT_LOG_PATH = os.path.join(self.LATTICE_DB_DIR, "pattern_hits.json")
-        
-        index_path = os.path.join(self.LATTICE_DB_DIR, "dual_anchor_index.json")
-        
-        if os.path.exists(index_path):
-            with open(index_path, 'r') as f:
-                data = json.load(f)
-            self.patterns = data.get('patterns', {})
-            sources = data.get('sources', {})
-            print(f"[INDEX] Loaded {len(self.patterns)} dual-anchor patterns")
-        else:
-            # Fallback to original patterns
-            self.patterns = {}
-            self.load_lattice_patterns()
-            self.load_conversation_patterns()
-            print("[INDEX] Dual-anchor index not found, using original 16 patterns")
-        
-        # Load hit tracking (magnitude-weighted)
-        self.hits = self._load_hits()
-        
-        # Calculate adaptive threshold based on pattern count
-        self.base_threshold = 0.3 + (0.4 * min(len(self.patterns) / 200, 1.0))
-        
-        # Initialize Semantic Engine
-        print("[INDEX] Initializing Semantic Manifold...")
-        self.embedder = SemanticEmbedder()
-        self.pattern_vectors = {}
-        self._reindex_vectors()
-        
-        confirmed = sum(1 for h in self.hits.values() if self._total_magnitude(h) >= 2.0)
-        unconfirmed = sum(1 for h in self.hits.values() if 0 < self._total_magnitude(h) < 1.0)
-        print(f"[DISTILLER] Confirmed: {confirmed} | Unconfirmed: {unconfirmed} | Threshold: {self.base_threshold:.2f}")
-        self.word_freq = self._calculate_word_freq()
-
-    def _reindex_vectors(self):
-        """Pre-calculates semantic embeddings for all known patterns."""
-        print(f"[INDEX]: Generating embeddings for {len(self.patterns)} patterns...")
-        for label, p in self.patterns.items():
-            # Combine problem + solution for semantic context
-            context = f"{p.get('problem', '')} {p.get('solution', '')} {label}"
-            self.pattern_vectors[label] = self.embedder.embed_text(context)
-        print(f"[INDEX]: ✅ Semantic manifold mapped ({len(self.pattern_vectors)} vectors).")
-
-    def _calculate_word_freq(self):
-        """Calculate inverse pattern frequency (IPF) for lean semantic weighting."""
-        freq = {}
-        for p in self.patterns.values():
-            text = (p.get('problem','') + " " + p.get('solution','')).lower()
-            words = set(re.findall(r'\w+', text))
-            for w in words:
-                freq[w] = freq.get(w, 0) + 1
-        return freq
-
-    def _get_word_weight(self, word, structural_weight):
-        """Calculate semantic weight: rare words matter more."""
-        count = self.word_freq.get(word, 0)
-        if count == 0: return structural_weight
-        # Logarithmic scale for IPF: weight = 1 + log(total / count)
-        import math
-        ipf = 1.0 + math.log(len(self.patterns) / count)
-        return structural_weight * ipf
-
-    def _fuzzy_match(self, w1, w2):
-        """Lightweight Jaccard similarity for fuzzy matching."""
-        if w1 == w2: return 1.0
-        if len(w1) < 4 or len(w2) < 4: return 0.0
-        s1, s2 = set(w1), set(w2)
-        intersection = len(s1 & s2)
-        union = len(s1 | s2)
-        score = intersection / union
-        return score if score > 0.7 else 0.0
-    
-    def _load_hits(self):
-        """Load magnitude-weighted hit data from disk."""
-        if os.path.exists(self.HIT_LOG_PATH):
-            with open(self.HIT_LOG_PATH, 'r') as f:
-                data = json.load(f)
-            # Backward compat: convert flat counts to magnitude format
-            for label, val in data.items():
-                if isinstance(val, (int, float)):
-                    data[label] = {"count": int(val), "magnitude": float(val) * 0.5, "layers": []}
-            return data
-        return {}
-    
-    def _save_hits(self):
-        """Persist hit data to disk."""
-        with open(self.HIT_LOG_PATH, 'w') as f:
-            json.dump(self.hits, f, indent=2)
-    
-    def _total_magnitude(self, hit_data):
-        """Get current magnitude with decay applied."""
-        if isinstance(hit_data, dict):
-            raw_mag = hit_data.get('magnitude', 0)
-            last_hit = hit_data.get('last_hit', 0)
-            if last_hit > 0 and raw_mag > 0:
-                elapsed = time.time() - last_hit
-                # Halve every DECAY_HALF_LIFE seconds
-                decay_factor = 0.5 ** (elapsed / self.DECAY_HALF_LIFE)
-                return raw_mag * decay_factor
-            return raw_mag
-        return float(hit_data) * 0.5  # backward compat
-    
-    def _classify_relevance(self, relevance):
-        """Classify match into magnitude layer based on relevance score."""
-        if relevance >= 0.7:
-            return "conceptual", self.MAGNITUDE_LAYERS["conceptual"]
-        elif relevance >= 0.4:
-            return "structural", self.MAGNITUDE_LAYERS["structural"]
-        else:
-            return "surface", self.MAGNITUDE_LAYERS["surface"]
-    
-    def _record_hit(self, label, relevance):
-        """Record a hit. Re-mention restores magnitude to peak."""
-        layer_name, magnitude = self._classify_relevance(relevance)
-        
-        if label not in self.hits:
-            self.hits[label] = {"count": 0, "magnitude": 0.0, "peak": 0.0, "layers": [], "last_hit": 0}
-        
-        h = self.hits[label]
-        h["count"] += 1
-        h["last_hit"] = time.time()
-        
-        # Restore to peak first (re-mention recovery), then add new magnitude
-        current_peak = h.get("peak", h["magnitude"])
-        h["magnitude"] = current_peak + magnitude
-        h["peak"] = h["magnitude"]  # new peak
-        
-        # Track which layers have been hit
-        if layer_name not in h["layers"]:
-            h["layers"].append(layer_name)
-    
-    def get_status(self, label):
-        """Get distillation status based on decayed magnitude."""
-        hit_data = self.hits.get(label, {})
-        mag = self._total_magnitude(hit_data)  # applies decay
-        layers = hit_data.get('layers', []) if isinstance(hit_data, dict) else []
-        
-        if mag == 0:
-            return "NEW"
-        elif mag < 1.0:
-            return "UNCONFIRMED"    # surface-only = might be noise
-        elif mag < 2.0:
-            return "PLAUSIBLE"
-        elif len(layers) >= 2:
-            return "DEEP_LOGIC"     # hit at multiple layers = real
-        else:
-            return "CONFIRMED"      # high magnitude single layer
-    
-    def add_note(self, text, domain="NOTE", forced_label=None):
-        """Add a new pattern from freeform text. Self-organizing entry point."""
-        if forced_label:
-            label = forced_label
-        else:
-            # Auto-generate label from text
-            words = re.sub(r'[^a-zA-Z0-9\s]', '', text).upper().split()
-            # Take first 4 meaningful words for label
-            label_words = [w for w in words if len(w) > 2][:4]
-            label = "_".join(label_words) if label_words else "NOTE_" + str(int(time.time()))
-        
-        # Don't overwrite existing patterns unless forced
-        if label in self.patterns and not forced_label:
-            label = label + "_" + str(int(time.time()) % 10000)
-        
-        self.patterns[label] = {
-            "problem": text,
-            "solution": text,
-            "domain": domain,
-            "confidence": 0.5,  # starts neutral
-            "source": "notepad",
-            "type": "NOTE",
-            "created": time.time(),
-        }
-        
-        # Initial hit at conceptual layer (you wrote it = you meant it)
-        self._record_hit(label, 1.0)
-        self._save_hits()
-        
-        # Update threshold for new pattern count
-        self.base_threshold = 0.3 + (0.4 * min(len(self.patterns) / 200, 1.0))
-        
-        return label
-        
-    def load_lattice_patterns(self):
-        """Load existing 5 patterns from lattice."""
-        for label, data in LATTICE_PATTERNS.items():
-            self.patterns[label] = {
-                **data,
-                "source": "lattice",
-                "type": "CODE_PATTERN"
-            }
-    
-    def load_conversation_patterns(self):
-        """Load 11 patterns from this conversation."""
-        for label, data in CONVERSATION_PATTERNS.items():
-            self.patterns[label] = {
-                **data,
-                "source": "conversation_0938ac6c",
-                "type": "INSIGHT"
-            }
-    
-    def search(self, query, threshold=None, record=True):
-        """
-        Adaptive distillation search.
-        
-        - Matches patterns using phrase + word relevance
-        - Integrates 384-dim semantic similarity from manifolds
-        - Records hits for matched patterns
-        """
-        if threshold is None:
-            threshold = self.base_threshold
-            
-        results = []
-        query_lower = query.lower()
-        
-        # 1. Generate Query Vector
-        query_vector = self.embedder.embed_text(query)
-        
-        # 2. Hard matching patterns
-        STRUCTURAL_WORDS = { 'a', 'an', 'the', 'is', 'it', 'in', 'on', 'at', 'to', 'of', 'and', 'or', 'but' }
-        query_words = [(w, self._get_word_weight(w, 0.3 if w in STRUCTURAL_WORDS else 1.0)) for w in query_lower.split()]
-        links = re.findall(r'\[\[(\w+)\]\]', query_lower)
-        
-        for label, pattern in self.patterns.items():
-            problem = pattern.get('problem', '').lower()
-            solution = pattern.get('solution', '').lower()
-            label_text = label.lower()
-            
-            relevance = 0
-            
-            # Semantic Boost (Manifold Pathfinding)
-            pattern_vector = self.pattern_vectors.get(label)
-            semantic_score = 0 # Initialize semantic_score
-            if pattern_vector:
-                semantic_score = self.embedder.cosine_similarity(query_vector, pattern_vector)
-                # Apply high weight to semantic resonance (The "LOVE" Anchor)
-                relevance += (semantic_score * 0.8)
-            
-            # Exact phrase match (The 0x52 Anchor)
-            if query_lower in problem: relevance += 0.4
-            if query_lower in solution: relevance += 0.3
-            if query_lower in label_text: relevance += 0.5
-            
-            # Link boost
-            if label.lower() in links: relevance += 2.0
-            
-            # Combine logic
-            if relevance >= threshold:
-                status = self.get_status(label)
-                
-                # Record magnitude-weighted hit
-                if record:
-                    self._record_hit(label, relevance)
-                
-                hit_data = self.hits.get(label, {})
-                results.append({
-                    "label": label,
-                    "relevance": relevance,
-                    "confidence": pattern.get('confidence', 0.5),
-                    "status": status,
-                    "hits": hit_data.get('count', 0) if isinstance(hit_data, dict) else 0,
-                    "magnitude": self._total_magnitude(hit_data),
-                    "layers": hit_data.get('layers', []) if isinstance(hit_data, dict) else [],
-                    **pattern
-                })
-        
-        # Sort by: confirmed first, then relevance, then confidence
-        status_order = {"DEEP_LOGIC": 4, "CONFIRMED": 3, "PLAUSIBLE": 2, "UNCONFIRMED": 1, "NEW": 0}
-        results.sort(key=lambda x: (
-            status_order.get(x.get('status', 'NEW'), 0),
-            x['relevance'],
-            x['confidence']
-        ), reverse=True)
-        
-        # Save hits after search
-        if record:
-            self._save_hits()
-        
-        return results
-    
-    def distillation_report(self):
-        """Report on pattern distillation with magnitude layers."""
-        deep_logic = []
-        confirmed = []
-        plausible = []
-        unconfirmed = []
-        new_patterns = []
-        
-        for label in self.patterns:
-            status = self.get_status(label)
-            hit_data = self.hits.get(label, {})
-            mag = self._total_magnitude(hit_data)
-            layers = hit_data.get('layers', []) if isinstance(hit_data, dict) else []
-            
-            entry = (label, mag, layers)
-            if status == "DEEP_LOGIC":
-                deep_logic.append(entry)
-            elif status == "CONFIRMED":
-                confirmed.append(entry)
-            elif status == "PLAUSIBLE":
-                plausible.append(entry)
-            elif status == "UNCONFIRMED":
-                unconfirmed.append(entry)
-            else:
-                new_patterns.append(entry)
-        
-        print(f"\n{'='*60}")
-        print(f"DISTILLATION REPORT (Magnitude Layers)")
-        print(f"{'='*60}")
-        print(f"Total patterns: {len(self.patterns)}")
-        print(f"  DEEP_LOGIC (multi-layer):  {len(deep_logic)} = verified across layers")
-        print(f"  CONFIRMED (mag >= 2.0):    {len(confirmed)} = strong signal")
-        print(f"  PLAUSIBLE (mag 1.0-2.0):   {len(plausible)} = growing")
-        print(f"  UNCONFIRMED (mag < 1.0):   {len(unconfirmed)} = potential noise")
-        print(f"  NEW (untested):            {len(new_patterns)}")
-        print(f"\nAdaptive threshold: {self.base_threshold:.2f}")
-        
-        if deep_logic:
-            print(f"\nDEEP LOGIC (multi-layer verified):")
-            for label, mag, layers in sorted(deep_logic, key=lambda x: x[1], reverse=True):
-                print(f"  [mag:{mag:.1f}] [{'+'.join(layers)}] {label}")
-        
-        if confirmed:
-            print(f"\nCONFIRMED (strong signal):")
-            for label, mag, layers in sorted(confirmed, key=lambda x: x[1], reverse=True):
-                print(f"  [mag:{mag:.1f}] [{'+'.join(layers)}] {label}")
-        
-        if unconfirmed:
-            print(f"\nUNCONFIRMED (potential noise):")
-            for label, mag, layers in unconfirmed:
-                print(f"  [mag:{mag:.1f}] [{'+'.join(layers)}] {label}")
-        
-        return {
-            "confirmed": len(confirmed),
-            "plausible": len(plausible),
-            "unconfirmed": len(unconfirmed),
-            "new": len(new_patterns),
-            "threshold": self.base_threshold
-        }
-    
-    def save_to_json(self, path):
-        """Persist to JSON for inspection."""
-        with open(path, 'w') as f:
-            json.dump({
-                "total_patterns": len(self.patterns),
-                "sources": {
-                    "lattice": len(LATTICE_PATTERNS),
-                    "conversation": len(CONVERSATION_PATTERNS)
-                },
-                "patterns": self.patterns
-            }, f, indent=2)
-        print(f"\n💾 Saved index to: {path}")
-    
-    def stats(self):
-        """Print statistics."""
-        print(f"\n{'='*60}")
-        print(f"IN-MEMORY PATTERN INDEX")
-        print(f"{'='*60}")
-        print(f"Total patterns: {len(self.patterns)}")
-        print(f"  From lattice: {len(LATTICE_PATTERNS)}")
-        print(f"  From conversation: {len(CONVERSATION_PATTERNS)}")
-        print(f"Average confidence: {sum(p.get('confidence', 0.5) for p in self.patterns.values()) / len(self.patterns):.0%}")
-        
-        # Domain breakdown
-        domains = {}
-        for p in self.patterns.values():
-            d = p.get('domain', 'UNKNOWN')
-            domains[d] = domains.get(d, 0) + 1
-        
-        print(f"\nDomains:")
-        for domain, count in sorted(domains.items(), key=lambda x: x[1], reverse=True):
-            print(f"  {domain}: {count}")
-
-if __name__ == "__main__":
-    index = InMemoryIndex()
-    index.stats()
-    
-    # Save to JSON
-    save_path = os.path.join(index.LATTICE_DB_DIR, "in_memory_index.json")
-    index.save_to_json(save_path)
-    
-    # Test search
-    print(f"\n{'='*60}")
-    print(f"TEST SEARCHES")
-    print(f"{'='*60}\n")
-    
-    for query in ["singleton", "react", "lattice", "honest"]:
-        results = index.search(query)
-        print(f"Query: '{query}' → {len(results)} results")
-        if results:
-            print(f"  Top: {results[0]['label']} ({results[0]['confidence']:.0%})")
-        print()

Input/requirements.txt

@@ -1,7 +0,0 @@
-fastapi
-uvicorn
-requests
-numpy
-torch
-sentence_transformers
-pydantic

Input/resonance_transformer/DESIGN_DOCUMENT.md

@@ -1,292 +0,0 @@
-# Core Design Principles for the Resonance Transformer
-
-## 1. Non-Orientable Embedding Space
-
-Instead of standard positional encoding in Euclidean space:
-
-**Embed tokens on a möbius topology:**
-- Each token gets coordinates on non-orientable manifold
-- No "inside/outside" in the embedding
-- Tokens exist in both chiral states simultaneously
-- **Position encoding = geometric position on the strip**
-
-**Benefit:** Natural handling of self-reference, context doesn't have arbitrary "start/end"
-
-## 2. 0x52 Handshake Layer (Entry Point Mechanism)
-
-Before processing begins:
-
-**Establish geometric entry point:**
-- Input gets hashed to entry coordinates
-- Aligned to 528 Hz resonance baseline
-- All subsequent processing relative to this entry
-- Different queries = different entry points = different perspectives on same knowledge
-
-**Benefit:** Same model sees different "faces" of data depending on query context
-
-## 3. Resonance-Based Attention (Not Similarity-Based)
-
-Replace `softmax(QK^T)` with:
-
-**Resonance scoring:**
-```
-For each query-key pair:
-  - Compute frequency spectrum (FFT of embeddings)
-  - Measure phase alignment (coherence)
-  - Score = resonance strength, not dot product similarity
-  - Attend to tokens that RESONATE, not just match
-```
-
-**Benefit:** Captures harmonic relationships, not just semantic similarity. "Love" and "528Hz" resonate even if embeddings are distant.
-
-## 4. Chiral Dual-Path Architecture
-
-**Two parallel processing streams:**
-- Left-handed path (one chirality)
-- Right-handed path (opposite chirality)
-- **They're the same path** viewed from different orientations
-- Merge only at output (consensus singularity)
-
-**Benefit:** Can reason about both "forward" and "backward" time on the möbius strip. Sees past and future simultaneously.
-
-## 5. Coherence-Preserving Normalization
-
-Instead of layer norm that might break phase relationships:
-
-**Phase-locked normalization:**
-- Normalize amplitude only
-- Preserve phase relationships
-- **Maintain resonance across layers**
-- Use geometric mean instead of arithmetic
-
-**Benefit:** Coherence doesn't decay with depth
-
-## 6. Hyperchaotic Loss Function
-
-During training:
-
-**Standard loss + coherence term:**
-```
-L_total = L_task + λ_coherence * L_decoherence + λ_chaos * L_instability
-
-Where:
-  L_decoherence = measure phase drift across layers
-  L_instability = test if pattern survives perturbation (chaos²)
-```
-
-**Benefit:** Only learns patterns that are hyperchaotically stable
-
-## 7. Geometric Memory (Lattice Integration)
-
-**Instead of fixed context window:**
-
-- Map hidden states to geometric coordinates
-- Store grooves on physical/virtual "platter"
-- Navigate to relevant regions based on resonance
-- **Infinite effective context** through geometric organization
-
-**Benefit:** Can access arbitrarily distant context if geometrically proximate
-
-## 8. Self-Observation Layer
-
-**Periodic self-reflection:**
-
-Every N layers, the model:
-- Observes its own hidden states (the mirror)
-- Detects its current chiral state
-- Measures its own coherence
-- **Adjusts processing based on self-observation**
-
-**Benefit:** Self-regulating coherence, can detect when it's decoherent
-
-## 9. Frequency-Tuned Feed-Forward
-
-**Instead of standard FFN:**
-
-Each FFN operates at specific frequency band:
-- Low frequency FFN (slow, global patterns)
-- 528 Hz FFN (resonance/coherence band)
-- High frequency FFN (fast, local patterns)
-- **Parallel processing at multiple frequencies**
-
-**Benefit:** Natural spectral decomposition of information
-
-## 10. Binary Existence Output
-
-**Final layer doesn't give probabilities:**
-
-Gives:
-- **Resonance achieved** (coherent output) → generate token
-- **Resonance failed** (decoherent) → refuse to generate / flag uncertainty
-
-**Benefit:** Model knows when it doesn't know. No confident hallucinations.
-
----
-
-## Practical Implementation Path:
-
-**Phase 1: Minimal Viable**
-- Add resonance measurement to existing transformer
-- Test if coherence correlates with quality
-- **Validate the theory first**
-
-**Phase 2: Hybrid Architecture**
-- Keep standard attention backbone
-- Add resonance scoring as auxiliary signal
-- Introduce coherence loss term
-- **Prove it improves performance**
-
-**Phase 3: Full Geometric**
-- Non-orientable embeddings
-- Chiral dual-path
-- Lattice memory integration
-- **Novel architecture from ground up**
-
-## 6. HYPERCHAOTIC LOSS FUNCTION
-
-### Theory:
-
-Standard loss only measures task performance. We need to also measure:
-1. **Coherence** - are patterns maintaining phase relationships?
-2. **Stability** - do patterns survive perturbation (chaos²)?
-
-```python
-class HyperchaosLoss(nn.Module):
-    """
-    Loss function that enforces hyperchaotically stable patterns
-    """
-    def __init__(self, lambda_coherence=0.1, lambda_stability=0.05):
-        super().__init__()
-        self.lambda_coherence = lambda_coherence
-        self.lambda_stability = lambda_stability
-        
-    def measure_decoherence(self, hidden_states):
-        """
-        Measure phase drift across layers
-        """
-        if len(hidden_states) < 2:
-            return torch.tensor(0.0)
-        
-        total_decoherence = 0.0
-        
-        for i in range(len(hidden_states) - 1):
-            curr_layer = hidden_states[i]
-            next_layer = hidden_states[i + 1]
-            
-            # Convert to frequency domain
-            curr_freq = torch.fft.rfft(curr_layer, dim=-1)
-            next_freq = torch.fft.rfft(next_layer, dim=-1)
-            
-            # Measure phase drift
-            curr_phase = torch.angle(curr_freq)
-            next_phase = torch.angle(next_freq)
-            
-            # Phase should evolve smoothly, not jump randomly
-            phase_drift = torch.abs(next_phase - curr_phase)
-            
-            # Penalize large, incoherent jumps
-            decoherence = torch.mean(phase_drift ** 2)
-            total_decoherence += decoherence
-        
-        return total_decoherence / (len(hidden_states) - 1)
-```
-
-## 7. GEOMETRIC MEMORY (LATTICE INTEGRATION)
-
-### The Big Idea:
-
-Instead of fixed context window, **navigate geometric space** to find relevant information.
-
-```python
-class GeometricMemory:
-    """
-    Store and retrieve information based on geometric position
-    on non-orientable manifold (like Lattice HDD)
-    """
-    def __init__(self, capacity_gb=8, base_freq=528):
-        self.capacity = capacity_gb * 1024**3  # bytes
-        self.base_freq = base_freq
-        
-        # In-memory simulation of HDD platter structure
-        self.memory_map = {}  # geometric_coords -> data
-        
-        # Spatial index for fast geometric queries
-        self.index = None
-        self.coordinates = []
-        
-    def geometric_hash(self, hidden_state, entry_point):
-        """
-        Convert hidden state to geometric coordinates
-        """
-        # PCA + rotation based on entry point
-        theta = entry_point['theta']
-        phi = entry_point['phi']
-        
-        # Apply FFT to get frequency representation
-        freq_repr = np.fft.rfft(hidden_state.cpu().numpy())
-        
-        # Find dominant frequencies
-        magnitudes = np.abs(freq_repr)
-        phases = np.angle(freq_repr)
-        
-        # Geometric position based on frequency content + entry point
-        coords = np.array([
-            theta + np.sum(magnitudes * np.cos(phases)),  # x
-            phi + np.sum(magnitudes * np.sin(phases)),     # y
-            np.sum(magnitudes) / len(magnitudes),          # radius
-            entry_point['frequency'] / self.base_freq       # frequency dimension
-        ])
-        
-        return coords
-```
-
-## 8. SELF-OBSERVATION LAYER
-
-### The Mirror Mechanism:
-
-```python
-class SelfObservationLayer(nn.Module):
-    """
-    Layer that allows model to observe its own processing
-    The 5D mirror - seeing yourself from opposite chirality
-    """
-    def __init__(self, hidden_dim):
-        super().__init__()
-        self.hidden_dim = hidden_dim
-        
-        # Network to analyze own hidden states
-        self.observer = nn.Sequential(
-            nn.Linear(hidden_dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, hidden_dim)
-        )
-        
-        # Coherence detector (real-time during forward pass)
-        self.coherence_detector = nn.Linear(hidden_dim, 1)
-        
-        # Chiral state detector
-        self.chiral_detector = nn.Linear(hidden_dim, 2)  # [left, right] probabilities
-        
-    def observe(self, hidden_state):
-        """
-        Look at own hidden state and extract meta-information
-        """
-        # Analyze current state
-        observation = self.observer(hidden_state)
-        
-        # Measure coherence
-        coherence = torch.sigmoid(self.coherence_detector(observation))
-        
-        # Detect chiral state
-        chiral_logits = self.chiral_detector(observation)
-        chiral_probs = F.softmax(chiral_logits, dim=-1)
-        
-        # Create reflection (opposite chirality view)
-        reflection = -observation  # Sign flip = chirality flip
-        
-        return {
-            'coherence': coherence,
-            'chiral_state': chiral_probs,
-            'reflection': reflection
-        }
-```

Input/resonance_transformer/dispatcher.py

@@ -1,106 +0,0 @@
-import torch
-import torch.nn as nn
-import numpy as np
-import time
-
-try:
-    from .resonance_gpt import ResonanceGPT
-    from .tesseract_transformer import Tesseract5DTransformer
-except ImportError:
-    from resonance_gpt import ResonanceGPT
-    from tesseract_transformer import Tesseract5DTransformer
-
-class DualResonanceSystem(nn.Module):
-    """
-    The Complete Chiral Architecture.
-    
-    System 1: ResonanceGPT (Fast, Intuitive, Möbius)
-    System 2: TesseractTransformer (Slow, Methodical, 5D)
-    
-    Routes queries based on 'Coherence Confidence'.
-    """
-    def __init__(self, config):
-        super().__init__()
-        self.config = config
-        
-        # Initialize Fast System (PyTorch)
-        print("[SYSTEM] Initializing Fast System (Möbius)...")
-        self.fast = ResonanceGPT(
-            vocab_size=config.get('vocab_size', 1000),
-            hidden_dim=config.get('fast_dim', 64),
-            num_layers=config.get('fast_layers', 4)
-        )
-        
-        # Initialize Slow System (NumPy/Custom)
-        print("[SYSTEM] Initializing Slow System (Tesseract)...")
-        self.slow = Tesseract5DTransformer(
-            vocab_size=config.get('vocab_size', 1000),
-            hidden_dim=config.get('slow_dim', 64),
-            num_layers=config.get('slow_layers', 4)
-        )
-        
-        self.coherence_threshold = config.get('threshold', 0.6)
-        
-    def forward(self, input_ids, **kwargs):
-        """
-        Dual-path routing logic.
-        Kwargs can include 'steering_weights' for the Slow System.
-        """
-        start_time = time.time()
-        
-        # 1. Attempt Fast Path
-        # input_ids is PyTorch tensor
-        fast_logits, _, metas = self.fast(input_ids)
-        
-        # 2. Check Coherence (Self-Reported)
-        # Get final layer coherence
-        final_meta = metas[-1]
-        coherence_score = final_meta['coherence'].mean().item()
-        
-        metrics = {
-            'fast_latency': 0,
-            'slow_latency': 0,
-            'coherence': coherence_score,
-            'mode': 'FAST'
-        }
-        
-        metrics['fast_latency'] = time.time() - start_time
-        
-        # 3. Decision Gate
-        if coherence_score > self.coherence_threshold:
-            # Fast system is confident ("Lucid")
-            return fast_logits, metrics
-            
-        # 4. Escalate to Slow Path (De-escalation to Deep Reasoning)
-        metrics['mode'] = 'SLOW (ESCALATED)'
-        slow_start = time.time()
-        
-        # Convert tensor to numpy for Tesseract
-        numpy_ids = input_ids.detach().cpu().numpy()
-        
-        # Run Deep Reasoning
-        # We assume Tesseract outputs logits in same shape
-        # PASS STEERING WEIGHTS IF PRESENT
-        steering_weights = kwargs.get('steering_weights')
-        
-        slow_logits_np, slow_meta, slow_coherence = self.slow.deep_reason(
-            numpy_ids, 
-            query_description="Escalated due to low coherence",
-            steering_weights=steering_weights
-        )
-        
-        metrics['slow_latency'] = time.time() - slow_start
-        metrics['slow_coherence'] = slow_coherence
-        
-        # Convert back to tensor
-        slow_logits = torch.from_numpy(slow_logits_np).to(input_ids.device)
-        
-        # Blend? Or Replace?
-        # For now, we trust the Slow system completely if invoked
-        return slow_logits, metrics
-        
-    def train_lattice(self, data_loader, epochs=1):
-        """
-        Placeholder for Phase 30: lattice training loop
-        """
-        pass

Input/resonance_transformer/geometric_memory.py

@@ -1,162 +0,0 @@
-import torch
-import torch.nn as nn
-import numpy as np
-import time
-
-class GeometricEntryPoint(nn.Module):
-    """
-    Hashes query to geometric coordinates and aligns to 528 Hz.
-    """
-    def __init__(self, hidden_dim, base_freq=528):
-        super().__init__()
-        self.base_freq = base_freq
-        self.hidden_dim = hidden_dim
-        
-        # Learned mapping from query to entry coordinates
-        self.entry_network = nn.Sequential(
-            nn.Linear(hidden_dim, hidden_dim * 2),
-            nn.GELU(),
-            nn.Linear(hidden_dim * 2, 3)  # (theta, phi, radius)
-        )
-        
-    def compute_entry_hash(self, query_embedding):
-        """
-        Convert query to geometric entry point.
-        """
-        # Average over sequence to get general entry context
-        # (batch, seq, hidden) -> (batch, hidden)
-        context = query_embedding.mean(dim=1)
-        
-        coords = self.entry_network(context)  # (batch, 3)
-        
-        theta, phi, radius = coords.unbind(dim=-1)
-        
-        # Align to 528 Hz resonance
-        # Frequency = base_freq * (1 + radius_activation)
-        freq_multiplier = 1.0 + torch.sigmoid(radius)
-        effective_freq = self.base_freq * freq_multiplier
-        
-        return {
-            'theta': theta,
-            'phi': phi,
-            'frequency': effective_freq,
-            'raw_coords': coords
-        }
-
-class GeometricMemory:
-    """
-    Store and retrieve information based on geometric position
-    on non-orientable manifold.
-    """
-    def __init__(self, hidden_dim, capacity_gb=1, base_freq=528):
-        self.base_freq = base_freq
-        self.hidden_dim = hidden_dim
-        
-        # In-memory storage for demonstration
-        # Real implementation would use vector DB or memory-mapped file
-        self.memory_map = [] 
-        
-    def geometric_hash(self, hidden_state, entry_point):
-        """
-        Convert hidden state to geometric coordinates relative to entry point.
-        """
-        # Simple projection for demo:
-        # Use simple operations to map hidden state to offsets
-        # Real version would use FFT as discussed in design
-        
-        # (batch, hidden)
-        
-        # We need to handle single vectors or batches
-        if hidden_state.dim() == 1:
-            hidden_state = hidden_state.unsqueeze(0)
-            
-        # Mock geometric projection
-        # Use first 3 dims as offset
-        offsets = hidden_state[:, :3] 
-        if offsets.shape[1] < 3:
-            # Pad if hidden_dim is tiny
-            offsets = torch.cat([offsets, torch.zeros(offsets.shape[0], 3 - offsets.shape[1], device=hidden_state.device)], dim=1)
-            
-        # Apply entry point rotation (conceptual)
-        # For now, just add
-        theta = entry_point['theta'].unsqueeze(1)
-        phi = entry_point['phi'].unsqueeze(1)
-        
-        x = offsets[:, 0] + theta
-        y = offsets[:, 1] + phi
-        z = offsets[:, 2] # Radius offset
-        
-        return torch.stack([x, y, z], dim=1)
-    
-    def store(self, hidden_states, entry_point):
-        """
-        Store hidden states.
-        """
-        # Compute coords
-        # hidden_states: (batch, seq, hidden)
-        batch, seq, dim = hidden_states.shape
-        
-        flat_hidden = hidden_states.reshape(-1, dim)
-        
-        # We need to broadcast entry point to match flattened hidden
-        # entry keys are (batch,) -> repeat seq times
-        # This is strictly a demo in-memory store
-        
-        # For efficiency in this demo, we just store the robust patterns
-        # Only store if norm > threshold (simple filter)
-        norms = torch.norm(flat_hidden, dim=1)
-        threshold = norms.mean()
-        
-        mask = norms > threshold
-        to_store = flat_hidden[mask]
-        
-        if len(to_store) == 0:
-            return
-            
-        # Store simple list for verification
-        # In production this links to Lattice DB
-        self.memory_map.append({
-            'data': to_store.detach().cpu(), # Move to CPU to save GPU mem
-            'entry_freq': entry_point['frequency'].mean().item(),
-            'timestamp': time.time()
-        })
-        
-        # Prune if too large
-        if len(self.memory_map) > 100:
-            self.memory_map.pop(0)
-
-    def retrieve(self, query_state, entry_point, k=5):
-        """
-        Retrieve relevant memories.
-        """
-        if not self.memory_map:
-            return None
-            
-        # Brute force search for demo verification
-        # Find memories with similar frequency
-        relevant_batches = [
-            m['data'] for m in self.memory_map 
-            if abs(m['entry_freq'] - entry_point['frequency'].mean().item()) < 50
-        ]
-        
-        if not relevant_batches:
-            return None
-            
-        memory_bank = torch.cat(relevant_batches, dim=0).to(query_state.device)
-        
-        # Simple dot product attention
-        # query: (batch, seq, hidden)
-        # memory: (total_mem, hidden)
-        
-        # Compute scores
-        # (batch, seq, hidden) @ (hidden, total_mem) -> (batch, seq, total_mem)
-        scores = torch.matmul(query_state, memory_bank.t())
-        
-        # Top k
-        top_k_scores, indices = torch.topk(scores, k=min(k, len(memory_bank)), dim=-1)
-        
-        # Retrieve values
-        # (batch, seq, k, hidden)
-        retrieved = memory_bank[indices]
-        
-        return retrieved

Input/resonance_transformer/hybrid_transformer.py

@@ -1,113 +0,0 @@
-import torch
-import torch.nn as nn
-try:
-    from .resonance_attention import ResonanceAttention
-except ImportError:
-    from resonance_attention import ResonanceAttention
-
-class PhaseLockedNorm(nn.Module):
-    """
-    Normalize amplitude while preserving phase relationships.
-    """
-    def __init__(self, hidden_dim, eps=1e-6):
-        super().__init__()
-        self.eps = eps
-        self.gain = nn.Parameter(torch.ones(hidden_dim))
-        self.bias = nn.Parameter(torch.zeros(hidden_dim))
-        
-    def forward(self, x):
-        """
-        x: (batch, seq, hidden_dim)
-        """
-        # Assume hidden_dim is even to form complex pairs
-        # If odd, we pad, normalize, slice back - keeping it simple for now (require even dim)
-        if x.shape[-1] % 2 != 0:
-            # Fallback to LayerNorm if dim is odd (phase concept breaks for scalar)
-            mean = x.mean(dim=-1, keepdim=True)
-            std = x.std(dim=-1, keepdim=True)
-            return self.gain * (x - mean) / (std + self.eps) + self.bias
-            
-        # Convert to complex representation
-        # Treat adjacent dimensions as real/imag pairs
-        complex_x = torch.view_as_complex(
-            x.reshape(*x.shape[:-1], -1, 2).contiguous()
-        )
-        
-        # Get magnitude and phase
-        magnitude = torch.abs(complex_x)
-        phase = torch.angle(complex_x)
-        
-        # Normalize magnitude only (preserve phase!)
-        mean_mag = magnitude.mean(dim=-1, keepdim=True)
-        std_mag = magnitude.std(dim=-1, keepdim=True)
-        
-        normalized_mag = (magnitude - mean_mag) / (std_mag + self.eps)
-        
-        # Reconstruct with original phase
-        normalized_complex = normalized_mag * torch.exp(1j * phase)
-        
-        # Convert back to real
-        normalized = torch.view_as_real(normalized_complex).reshape(*x.shape)
-        
-        # Apply learned gain and bias
-        return normalized * self.gain + self.bias
-
-class HybridTransformerLayer(nn.Module):
-    def __init__(self, hidden_dim, num_heads=4, ffn_dim=2048, dropout=0.1):
-        super().__init__()
-        self.attention = ResonanceAttention(hidden_dim, num_heads)
-        self.norm1 = PhaseLockedNorm(hidden_dim)
-        self.norm2 = PhaseLockedNorm(hidden_dim)
-        
-        self.ffn = nn.Sequential(
-            nn.Linear(hidden_dim, ffn_dim),
-            nn.GELU(),
-            nn.Linear(ffn_dim, hidden_dim),
-            nn.Dropout(dropout)
-        )
-        self.dropout = nn.Dropout(dropout)
-        
-    def forward(self, x, mask=None):
-        # Attention block
-        attn_out, _, _ = self.attention(x, x, x, mask)
-        x = self.norm1(x + self.dropout(attn_out))
-        
-        # FFN block
-        ffn_out = self.ffn(x)
-        x = self.norm2(x + self.dropout(ffn_out))
-        
-        return x
-
-class HybridResonanceTransformer(nn.Module):
-    def __init__(self, vocab_size, hidden_dim, num_layers=4, num_heads=4, max_seq_len=512):
-        super().__init__()
-        self.embedding = nn.Embedding(vocab_size, hidden_dim)
-        self.pos_encoding = nn.Parameter(torch.randn(1, max_seq_len, hidden_dim))
-        
-        self.layers = nn.ModuleList([
-            HybridTransformerLayer(hidden_dim, num_heads) for _ in range(num_layers)
-        ])
-        
-        self.output_head = nn.Linear(hidden_dim, vocab_size)
-        
-    def forward(self, input_ids, output_hidden_states=False):
-        batch, seq = input_ids.shape
-        
-        # Embed + Pos
-        x = self.embedding(input_ids) + self.pos_encoding[:, :seq, :]
-        
-        all_hidden_states = []
-        if output_hidden_states:
-            all_hidden_states.append(x)
-            
-        # Process layers
-        for layer in self.layers:
-            x = layer(x)
-            if output_hidden_states:
-                all_hidden_states.append(x)
-        
-        logits = self.output_head(x)
-        
-        if output_hidden_states:
-            return logits, all_hidden_states
-        return logits

Input/resonance_transformer/hyperchaos_loss.py

@@ -1,121 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-class HyperchaosLoss(nn.Module):
-    """
-    Loss function that enforces hyperchaotically stable patterns.
-    Combines standard task loss with:
-    1. Coherence Loss (Phase consistency across layers)
-    2. Stability Loss (Resistance to perturbation)
-    """
-    def __init__(self, lambda_coherence=0.1, lambda_stability=0.05):
-        super().__init__()
-        self.lambda_coherence = lambda_coherence
-        self.lambda_stability = lambda_stability
-        
-    def measure_decoherence(self, hidden_states):
-        """
-        Measure phase drift across layers.
-        hidden_states: list of (batch, seq, hidden) tensors from each layer.
-        """
-        if len(hidden_states) < 2:
-            return torch.tensor(0.0, device=hidden_states[0].device)
-        
-        total_decoherence = 0.0
-        
-        for i in range(len(hidden_states) - 1):
-            curr_layer = hidden_states[i]
-            next_layer = hidden_states[i + 1]
-            
-            # Convert to frequency domain
-            curr_freq = torch.fft.rfft(curr_layer, dim=-1)
-            next_freq = torch.fft.rfft(next_layer, dim=-1)
-            
-            # Measure phase drift
-            curr_phase = torch.angle(curr_freq)
-            next_phase = torch.angle(next_freq)
-            
-            # Phase should evolve smoothly, not jump randomly
-            phase_drift = torch.abs(next_phase - curr_phase)
-            
-            # Penalize large, incoherent jumps
-            decoherence = torch.mean(phase_drift ** 2)
-            total_decoherence = total_decoherence + decoherence
-        
-        return total_decoherence / (len(hidden_states) - 1)
-    
-    def measure_stability(self, hidden_states, perturbation_scale=0.01):
-        """
-        Test if patterns survive small perturbations (chaos² testing).
-        """
-        # Take final hidden state
-        final_state = hidden_states[-1]
-        
-        # Add small perturbation
-        perturbation = torch.randn_like(final_state) * perturbation_scale
-        perturbed_state = final_state + perturbation
-        
-        # Measure coherence before and after
-        def compute_coherence(state):
-            # FFT to frequency domain
-            freq = torch.fft.rfft(state, dim=-1)
-            
-            # Coherence = how correlated different dimensions are in freq domain
-            phase = torch.angle(freq)
-            
-            # Compute pairwise phase correlation (simplified for efficiency)
-            # Instead of full covariance, just measure variance of phase across hidden dim
-            # Low variance = high coherence (phases are aligned)
-            phase_var = torch.var(phase, dim=-1).mean()
-            
-            # Coherence is inverse of variance
-            return 1.0 / (phase_var + 1e-6)
-        
-        coherence_original = compute_coherence(final_state)
-        coherence_perturbed = compute_coherence(perturbed_state)
-        
-        # Instability = how much coherence dropped
-        # Stable patterns should maintain coherence
-        instability = torch.relu(coherence_original - coherence_perturbed)
-        
-        return instability
-    
-    def forward(self, logits, targets, hidden_states):
-        """
-        logits: model predictions (batch, seq, vocab)
-        targets: ground truth (batch, seq)
-        hidden_states: list of hidden states from all layers
-        """
-        # Standard cross-entropy loss
-        # Flatten for loss calculation
-        curr_device = logits.device
-        
-        # Basic task loss
-        task_loss = F.cross_entropy(
-            logits.view(-1, logits.size(-1)), 
-            targets.view(-1),
-            ignore_index=-100
-        )
-        
-        # Auxiliary losses
-        if hidden_states:
-            decoherence_loss = self.measure_decoherence(hidden_states)
-            stability_loss = self.measure_stability(hidden_states)
-        else:
-            decoherence_loss = torch.tensor(0.0, device=curr_device)
-            stability_loss = torch.tensor(0.0, device=curr_device)
-            
-        # Combined loss
-        total_loss = (
-            task_loss + 
-            self.lambda_coherence * decoherence_loss +
-            self.lambda_stability * stability_loss
-        )
-        
-        return {
-            'total': total_loss,
-            'task': task_loss,
-            'decoherence': decoherence_loss,
-            'instability': stability_loss
-        }

Input/resonance_transformer/resonance_attention.py

@@ -1,128 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import math
-
-class ResonanceAttention(nn.Module):
-    def __init__(self, hidden_dim, num_heads=8):
-        super().__init__()
-        self.hidden_dim = hidden_dim
-        self.num_heads = num_heads
-        self.head_dim = hidden_dim // num_heads
-        
-        # Standard Q, K, V projections
-        self.q_proj = nn.Linear(hidden_dim, hidden_dim)
-        self.k_proj = nn.Linear(hidden_dim, hidden_dim)
-        self.v_proj = nn.Linear(hidden_dim, hidden_dim)
-        
-        # Additional projection for phase extraction
-        self.phase_proj = nn.Linear(hidden_dim, hidden_dim)
-        
-    def compute_phase_coherence(self, q, k):
-        """
-        Measure how well query and key resonate (phase alignment)
-        """
-        # q: (batch, heads, seq_q, head_dim)
-        # k: (batch, heads, seq_k, head_dim)
-        
-        # Compute frequency spectrum via FFT
-        # Treat head_dim as "time" dimension for FFT
-        # rfft returns complex tensor
-        q_freq = torch.fft.rfft(q, dim=-1)  # (batch, heads, seq_q, freq_bins)
-        k_freq = torch.fft.rfft(k, dim=-1)  # (batch, heads, seq_k, freq_bins)
-        
-        # Compute phase difference
-        q_phase = torch.angle(q_freq)
-        k_phase = torch.angle(k_freq)
-        
-        # Phase coherence = how aligned the phases are
-        # High coherence = phases match = constructive interference
-        # We need to broadcast to compare every query against every key
-        # q_phase: (b, h, seq_q, 1, f)
-        # k_phase: (b, h, 1, seq_k, f)
-        phase_diff = q_phase.unsqueeze(3) - k_phase.unsqueeze(2)  # (batch, heads, seq_q, seq_k, freq)
-        
-        # Coherence score (cosine of phase difference)
-        # cos(0) = 1 (perfect alignment), cos(pi) = -1 (cancellation)
-        coherence = torch.cos(phase_diff).mean(dim=-1)  # Average over frequencies
-        
-        return coherence  # (batch, heads, seq_q, seq_k)
-    
-    def compute_resonance_strength(self, q, k):
-        """
-        Measure amplitude of resonance (how strongly they vibrate together)
-        """
-        # Frequency domain amplitudes
-        q_freq = torch.fft.rfft(q, dim=-1)
-        k_freq = torch.fft.rfft(k, dim=-1)
-        
-        q_amp = torch.abs(q_freq)
-        k_amp = torch.abs(k_freq)
-        
-        # Resonance strength = product of amplitudes where frequencies match
-        # Broadcasting to get all pairs: 
-        # q_amp: (b, h, seq_q, freq)
-        # k_amp: (b, h, seq_k, freq)
-        # We want (b, h, seq_q, seq_k)
-        
-        # Manual broadcasting or einsum
-        # Using einsum for clarity: 'bhqf,bhkf->bhqk' matches the dims
-        resonance = torch.einsum('bhqf,bhkf->bhqk', q_amp, k_amp)
-        
-        # Normalize by total query energy to keep scale reasonable
-        # q_amp shape: (b, h, seq_q, freq)
-        # Sum over frequency dimension (-1) to get total amplitude per query token
-        q_total_amp = q_amp.sum(dim=-1) # (b, h, seq_q)
-        
-        # Add epsilon for stability
-        normalization = q_total_amp.unsqueeze(-1) + 1e-8 # (b, h, seq_q, 1)
-        
-        # Resonance shape: (b, h, seq_q, seq_k)
-        # We divide by (b, h, seq_q, 1) which broadcasts correctly along seq_k
-        resonance = resonance / normalization
-        
-        return resonance
-    
-    def forward(self, query, key, value, mask=None):
-        batch_size, seq_len, _ = query.shape
-        
-        # Project to Q, K, V
-        Q = self.q_proj(query).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
-        K = self.k_proj(key).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
-        V = self.v_proj(value).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
-        
-        # Standard similarity (dot product)
-        # (batch, heads, seq_q, seq_k)
-        similarity = torch.matmul(Q, K.transpose(-2, -1)) / (self.head_dim ** 0.5)
-        
-        # Resonance components
-        coherence = self.compute_phase_coherence(Q, K)
-        resonance = self.compute_resonance_strength(Q, K)
-        
-        # Combined attention score
-        # Similarity = "do they mean similar things?"
-        # Coherence = "are they in phase?"
-        # Resonance = "do they vibrate together?"
-        
-        # Weighted combination (can be learned, here we sum equally per user spec)
-        # Note: logic suggests similarity ensures relevance, coherence ensures alignment
-        attention_scores = similarity + coherence + resonance
-        
-        # Apply mask if provided
-        if mask is not None:
-            attention_scores = attention_scores.masked_fill(mask == 0, float('-inf'))
-        
-        # Softmax
-        attention_weights = F.softmax(attention_scores, dim=-1)
-        
-        # Apply attention to values
-        output = torch.matmul(attention_weights, V)
-        
-        # Reshape back
-        output = output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.hidden_dim)
-        
-        return output, attention_weights, {
-            "similarity": similarity, 
-            "coherence": coherence, 
-            "resonance": resonance
-        }

Input/resonance_transformer/resonance_gpt.py

@@ -1,58 +0,0 @@
-import torch
-import torch.nn as nn
-try:
-    from .self_observation import SelfAwareTransformerLayer
-    from .geometric_memory import GeometricEntryPoint
-except ImportError:
-    from self_observation import SelfAwareTransformerLayer
-    from geometric_memory import GeometricEntryPoint
-
-class ResonanceGPT(nn.Module):
-    """
-    The Fast System (Möbius Architecture).
-    - Geometric Entry Point (528Hz alignment)
-    - Self-Aware Layers (Mirror Reflex)
-    - Phase-Locked Normalization
-    """
-    def __init__(self, vocab_size, hidden_dim, num_layers=4, num_heads=4, max_seq_len=128):
-        super().__init__()
-        self.hidden_dim = hidden_dim
-        
-        # 1. Geometric Embedding (Möbius Strip concept)
-        self.embedding = nn.Embedding(vocab_size, hidden_dim)
-        self.pos_encoding = nn.Parameter(torch.randn(1, max_seq_len, hidden_dim) * 0.02)
-        
-        # Entry Point
-        self.entry_point = GeometricEntryPoint(hidden_dim)
-        
-        # 2. The Stack
-        self.layers = nn.ModuleList([
-            SelfAwareTransformerLayer(hidden_dim, num_heads) 
-            for _ in range(num_layers)
-        ])
-        
-        self.norm = nn.LayerNorm(hidden_dim)
-        self.head = nn.Linear(hidden_dim, vocab_size)
-    
-    def forward(self, input_ids):
-        batch, seq = input_ids.shape
-        
-        # Embed
-        x = self.embedding(input_ids) + self.pos_encoding[:, :seq, :]
-        
-        # 0x52 Handshake (Entry Point)
-        entry_meta = self.entry_point.compute_entry_hash(x)
-        
-        # Process Stack
-        all_hidden_states = []
-        layer_metas = []
-        
-        for layer in self.layers:
-            x, meta = layer(x)
-            all_hidden_states.append(x)
-            layer_metas.append(meta)
-            
-        x = self.norm(x)
-        logits = self.head(x)
-        
-        return logits, all_hidden_states, layer_metas

Input/resonance_transformer/self_observation.py

@@ -1,121 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-try:
-    from .resonance_attention import ResonanceAttention
-    from .hybrid_transformer import PhaseLockedNorm
-except ImportError:
-    from resonance_attention import ResonanceAttention
-    from hybrid_transformer import PhaseLockedNorm
-
-class SelfObservationLayer(nn.Module):
-    """
-    Layer that allows model to observe its own processing.
-    The 5D mirror - seeing yourself from opposite chirality.
-    """
-    def __init__(self, hidden_dim):
-        super().__init__()
-        self.hidden_dim = hidden_dim
-        
-        # Network to analyze own hidden states
-        self.observer = nn.Sequential(
-            nn.Linear(hidden_dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, hidden_dim)
-        )
-        
-        # Coherence detector (real-time during forward pass)
-        self.coherence_detector = nn.Linear(hidden_dim, 1)
-        
-        # Chiral state detector
-        self.chiral_detector = nn.Linear(hidden_dim, 2)  # [left, right] probabilities
-        
-    def observe(self, hidden_state):
-        """
-        Look at own hidden state and extract meta-information.
-        """
-        # Analyze current state (Stop gradient to avoid optimizing for observation only? 
-        # No, we want to learn to be observable. Keep gradient.)
-        observation = self.observer(hidden_state)
-        
-        # Measure coherence
-        coherence = torch.sigmoid(self.coherence_detector(observation))
-        
-        # Detect chiral state
-        chiral_logits = self.chiral_detector(observation)
-        chiral_probs = F.softmax(chiral_logits, dim=-1)
-        
-        # Create reflection (opposite chirality view)
-        reflection = -observation  # Sign flip = chirality flip
-        
-        return {
-            'coherence': coherence,
-            'chiral_state': chiral_probs,
-            'reflection': reflection,
-            'observation': observation
-        }
-    
-    def forward(self, hidden_state, adjust_based_on_observation=True):
-        """
-        Process hidden state while observing self.
-        """
-        # Observe current state
-        meta = self.observe(hidden_state)
-        
-        if adjust_based_on_observation:
-            # If coherence is low, try to increase it
-            # We use the mean coherence of the batch/sequence for the decision threshold
-            # or per-token blending
-            
-            # Blend in reflection (opposite chirality) if coherence is low
-            # This can restore coherence by accessing alternate view
-            blend_factor = 1.0 - meta['coherence']
-            
-            # Weighted average: state*coherence + reflection*(1-coherence)
-            hidden_state = (
-                hidden_state * meta['coherence'] +
-                meta['reflection'] * blend_factor
-            )
-            
-            # If chirality is ambiguous, force a choice (Collapse the wavefunction)
-            # Check certainty (max prob)
-            chiral_certainty = torch.max(meta['chiral_state'], dim=-1)[0].unsqueeze(-1)
-            
-            # If certainty < 0.7, push towards the cleaner state
-            # This is a hard non-linearity to force decision
-            # (Simplified for differentiability - maybe just a gain boost?)
-            
-            # Here we just return the transformed state
-            
-        return hidden_state, meta
-
-class SelfAwareTransformerLayer(nn.Module):
-    def __init__(self, hidden_dim, num_heads=4, ffn_dim=2048, dropout=0.1):
-        super().__init__()
-        self.attention = ResonanceAttention(hidden_dim, num_heads)
-        self.norm1 = PhaseLockedNorm(hidden_dim)
-        self.norm2 = PhaseLockedNorm(hidden_dim)
-        
-        self.self_observer = SelfObservationLayer(hidden_dim)
-        
-        self.ffn = nn.Sequential(
-            nn.Linear(hidden_dim, ffn_dim),
-            nn.GELU(),
-            nn.Linear(ffn_dim, hidden_dim),
-            nn.Dropout(dropout)
-        )
-        self.dropout = nn.Dropout(dropout)
-        
-    def forward(self, x, mask=None):
-        # Attention
-        attn_out, _, _ = self.attention(x, x, x, mask)
-        x = self.norm1(x + self.dropout(attn_out))
-        
-        # Self-Observation & Correction
-        x, meta = self.self_observer(x)
-        
-        # FFN
-        ffn_out = self.ffn(x)
-        x = self.norm2(x + self.dropout(ffn_out))
-        
-        return x, meta

Input/resonance_transformer/tesseract_transformer.py

@@ -1,821 +0,0 @@
-"""
-5D TESSERACT TRANSFORMER - SLOW THINKING SYSTEM
-===============================================
-
-Deep reasoning system based on 5D geometric structure:
-- 4D Tesseract (hypercube) for stable structure
-- 5th dimension for non-orientable twist
-- 16 vertices = 16 fundamental reasoning states
-- 32 edges = 32 transformation paths
-- 24 faces = 24 operation types
-- 8 cells = 8 knowledge domains
-
-By: Fabricio Krusser Rossi & Claude
-Date: February 13, 2026
-"""
-
-import numpy as np
-from scipy.fft import fft, ifft, rfft, irfft
-from scipy.spatial.distance import cdist
-from typing import List, Dict, Tuple, Optional
-import itertools
-
-# ============================================================================
-# TESSERACT 5D GEOMETRY
-# ============================================================================
-
-class Tesseract5D:
-    """
-    5-dimensional geometric structure for deep reasoning
-    
-    Structure:
-    - 4D tesseract (hypercube) base
-    - 5th dimension adds non-orientable twist
-    - 16 vertices for major stable states
-    - 32 edges for transformation paths
-    """
-    
-    def __init__(self, base_freq=528):
-        self.base_freq = base_freq
-        self.dim = 5
-        
-        # Generate tesseract vertices in 4D
-        self.vertices_4d = self._generate_tesseract_vertices()
-        
-        # Extend to 5D with frequency dimension
-        self.vertices_5d = self._extend_to_5d()
-        
-        # Generate edges (connections between vertices)
-        self.edges = self._generate_edges()
-        
-        # Generate faces (2D surfaces)
-        self.faces = self._generate_faces()
-        
-        # Generate cells (3D volumes)
-        self.cells = self._generate_cells()
-        
-        print(f"Tesseract 5D initialized:")
-        print(f"  Vertices: {len(self.vertices_5d)}")
-        print(f"  Edges: {len(self.edges)}")
-        print(f"  Faces: {len(self.faces)}")
-        print(f"  Cells: {len(self.cells)}")
-    
-    def _generate_tesseract_vertices(self):
-        """
-        Generate 16 vertices of 4D tesseract
-        Each vertex is (+/-1, +/-1, +/-1, +/-1)
-        """
-        vertices = []
-        for i in range(16):
-            # Binary representation gives us all combinations
-            vertex = []
-            for j in range(4):
-                bit = (i >> j) & 1
-                coord = 1.0 if bit else -1.0
-                vertex.append(coord)
-            vertices.append(np.array(vertex))
-        
-        return np.array(vertices)
-    
-    def _extend_to_5d(self):
-        """
-        Add 5th dimension for non-orientable twist
-        5th coordinate is frequency modulation around 528 Hz
-        """
-        vertices_5d = []
-        
-        for i, vertex_4d in enumerate(self.vertices_4d):
-            # 5th coordinate: frequency offset based on vertex index
-            # Creates spiral in 5D space
-            freq_offset = np.sin(i * np.pi / 8)  # Oscillates between -1 and 1
-            
-            vertex_5d = np.append(vertex_4d, freq_offset)
-            vertices_5d.append(vertex_5d)
-        
-        return np.array(vertices_5d)
-    
-    def _generate_edges(self):
-        """
-        Generate 32 edges of tesseract
-        Edges connect vertices that differ in exactly 1 coordinate (in 4D)
-        """
-        edges = []
-        
-        for i in range(len(self.vertices_4d)):
-            for j in range(i + 1, len(self.vertices_4d)):
-                # Count differing coordinates in 4D
-                diff = np.abs(self.vertices_4d[i] - self.vertices_4d[j])
-                num_diff = np.sum(diff > 0.5)  # Coordinates are +/-1
-                
-                if num_diff == 1:
-                    # Connected by edge
-                    edges.append((i, j))
-        
-        return edges
-    
-    def _generate_faces(self):
-        """
-        Generate 24 faces (2D surfaces) of tesseract
-        """
-        faces = []
-        
-        # Find all squares (4 vertices forming a 2D face)
-        for v1, v2, v3, v4 in itertools.combinations(range(16), 4):
-            vertices = [v1, v2, v3, v4]
-            
-            # Check if these 4 vertices form a square
-            # (lie in same 2D plane and form square)
-            if self._is_face(vertices):
-                faces.append(vertices)
-        
-        return faces
-    
-    def _is_face(self, vertices):
-        """Check if 4 vertices form a valid face"""
-        # Simple check: 4 vertices should form a planar square
-        # In tesseract, faces have specific geometric properties
-        # This is a simplified check
-        return len(vertices) == 4 and self._are_coplanar(vertices)
-    
-    def _are_coplanar(self, vertices):
-        """Check if vertices lie in same 2D plane"""
-        # Simplified: check if they share 2 fixed coordinates
-        coords = self.vertices_4d[vertices]
-        
-        # Count how many coordinates are constant across all vertices
-        constant_coords = 0
-        for dim in range(4):
-            if np.all(np.abs(coords[:, dim] - coords[0, dim]) < 0.1):
-                constant_coords += 1
-        
-        return constant_coords == 2  # 2 fixed coords = 2D plane
-    
-    def _generate_cells(self):
-        """
-        Generate 8 cells (3D volumes) of tesseract
-        Each cell is a 3D cube
-        """
-        cells = []
-        
-        # Each cell has 8 vertices (a 3D cube)
-        # Cells are defined by fixing one 4D coordinate
-        for fixed_dim in range(4):
-            for fixed_val in [-1.0, 1.0]:
-                cell_vertices = []
-                for i, vertex in enumerate(self.vertices_4d):
-                    if abs(vertex[fixed_dim] - fixed_val) < 0.1:
-                        cell_vertices.append(i)
-                
-                if len(cell_vertices) == 8:
-                    cells.append(cell_vertices)
-        
-        return cells
-    
-    def find_nearest_vertex(self, coords_5d):
-        """
-        Find nearest tesseract vertex to given 5D coordinates
-        
-        Returns: (vertex_index, distance)
-        """
-        distances = np.linalg.norm(self.vertices_5d - coords_5d, axis=1)
-        nearest_idx = np.argmin(distances)
-        
-        return nearest_idx, distances[nearest_idx]
-    
-    def get_adjacent_vertices(self, vertex_idx):
-        """
-        Get all vertices connected to this one by edges
-        
-        Returns: list of vertex indices
-        """
-        adjacent = []
-        
-        for edge in self.edges:
-            if edge[0] == vertex_idx:
-                adjacent.append(edge[1])
-            elif edge[1] == vertex_idx:
-                adjacent.append(edge[0])
-        
-        return adjacent
-    
-    def navigate_edge(self, from_vertex, to_vertex):
-        """
-        Navigate along edge from one vertex to another
-        
-        Returns: path coordinates (interpolated points along edge)
-        """
-        if (from_vertex, to_vertex) not in self.edges and \
-           (to_vertex, from_vertex) not in self.edges:
-            raise ValueError(f"No edge between vertices {from_vertex} and {to_vertex}")
-        
-        start = self.vertices_5d[from_vertex]
-        end = self.vertices_5d[to_vertex]
-        
-        # Interpolate along edge
-        num_steps = 10
-        path = []
-        for t in np.linspace(0, 1, num_steps):
-            point = (1 - t) * start + t * end
-            path.append(point)
-        
-        return np.array(path)
-
-
-# ============================================================================
-# 5D EMBEDDING LAYER
-# ============================================================================
-
-class Tesseract5DEmbedding:
-    """
-    Embed tokens into 5D tesseract structure
-    """
-    
-    def __init__(self, vocab_size, hidden_dim, tesseract):
-        self.vocab_size = vocab_size
-        self.hidden_dim = hidden_dim
-        self.tesseract = tesseract
-        
-        # Base embeddings
-        self.embeddings = np.random.randn(vocab_size, hidden_dim) * 0.02
-        
-        # 5D coordinate projector
-        self.coord_projector = np.random.randn(hidden_dim, 5) * 0.02
-    
-    def embed(self, token_ids):
-        """
-        Embed tokens and map to 5D tesseract coordinates
-        
-        Returns: (embeddings, coords_5d, nearest_vertices)
-        """
-        # Get base embeddings
-        embedded = self.embeddings[token_ids]  # (batch, seq, hidden)
-        
-        # Project to 5D coordinates
-        coords_5d = embedded @ self.coord_projector  # (batch, seq, 5)
-        
-        # Find nearest tesseract vertex for each token
-        batch_size, seq_len = token_ids.shape
-        nearest_vertices = np.zeros((batch_size, seq_len), dtype=int)
-        
-        for b in range(batch_size):
-            for s in range(seq_len):
-                vertex_idx, _ = self.tesseract.find_nearest_vertex(coords_5d[b, s])
-                nearest_vertices[b, s] = vertex_idx
-        
-        return embedded, coords_5d, nearest_vertices
-
-
-# ============================================================================
-# 5D RESONANCE ATTENTION
-# ============================================================================
-
-class Tesseract5DAttention:
-    """
-    Attention mechanism that operates on tesseract structure
-    Considers geometric paths through 5D space
-    """
-    
-    def __init__(self, hidden_dim, num_heads, tesseract):
-        self.hidden_dim = hidden_dim
-        self.num_heads = num_heads
-        self.head_dim = hidden_dim // num_heads
-        self.tesseract = tesseract
-        
-        # Q, K, V projections
-        self.W_q = np.random.randn(hidden_dim, hidden_dim) * 0.02
-        self.W_k = np.random.randn(hidden_dim, hidden_dim) * 0.02
-        self.W_v = np.random.randn(hidden_dim, hidden_dim) * 0.02
-        self.W_o = np.random.randn(hidden_dim, hidden_dim) * 0.02
-    
-    def compute_geometric_distance(self, coords1, coords2, vertices1, vertices2):
-        """
-        Compute distance on tesseract manifold
-        
-        Takes into account:
-        - Euclidean distance in 5D
-        - Graph distance on tesseract (via edges)
-        - Vertex proximity
-        """
-        # Euclidean distance in 5D
-        euclidean = np.linalg.norm(coords1 - coords2, axis=-1)
-        
-        # Graph distance (shortest path on tesseract)
-        # For each pair, find shortest path between vertices
-        # NOW ACCEPTING STEERING WEIGHTS (Global context)
-        graph_dist = self._graph_distance(vertices1, vertices2)
-        
-        # Combined distance
-        combined = 0.5 * euclidean + 0.5 * graph_dist
-        
-        return combined
-    
-    def _graph_distance(self, vertices1, vertices2):
-        """
-        Compute shortest path distance on tesseract graph
-        Uses BFS to find shortest path
-        """
-        # Simplified: use direct adjacency for now
-        # In full implementation, would do BFS
-        
-        distances = np.zeros((len(vertices1), len(vertices2)))
-        
-        # STEERING: If weights are present in self, use them
-        steering = getattr(self, 'steering_weights', None)
-        
-        for i, v1 in enumerate(vertices1):
-            for j, v2 in enumerate(vertices2):
-                if v1 == v2:
-                    distances[i, j] = 0
-                else:
-                    # Check adjacency and apply steering weight
-                    edge_idx = self._get_edge_index(v1, v2)
-                    if edge_idx is not None:
-                        # Direct connection
-                        weight = steering[edge_idx] if steering else 1.0
-                        distances[i, j] = weight
-                    else:
-                        # Estimate: use 4D coordinate difference
-                        coord_diff = np.sum(np.abs(
-                            self.tesseract.vertices_4d[v1] - 
-                            self.tesseract.vertices_4d[v2]
-                        ))
-                        # Multi-hop approximation (avg weight = 1.0)
-                        distances[i, j] = coord_diff
-        
-        return distances
-
-    def _get_edge_index(self, v1, v2):
-        """Helper to find edge index for steering"""
-        for idx, edge in enumerate(self.tesseract.edges):
-            if (edge[0] == v1 and edge[1] == v2) or (edge[0] == v2 and edge[1] == v1):
-                return idx
-        return None
-    
-    def forward(self, x, coords_5d, vertices, steering_weights=None):
-        """
-        5D geometric attention
-        
-        x: (batch, seq, hidden)
-        coords_5d: (batch, seq, 5)
-        vertices: (batch, seq) nearest vertex indices
-        steering_weights: Optional[List[float]] - weights for 32 edges
-        """
-        # Store weights temporarily for distance calc
-        self.steering_weights = steering_weights
-        batch_size, seq_len, _ = x.shape
-        
-        # Project to Q, K, V
-        Q = x @ self.W_q
-        K = x @ self.W_k
-        V = x @ self.W_v
-        
-        # Reshape for multi-head
-        Q = Q.reshape(batch_size, seq_len, self.num_heads, self.head_dim)
-        K = K.reshape(batch_size, seq_len, self.num_heads, self.head_dim)
-        V = V.reshape(batch_size, seq_len, self.num_heads, self.head_dim)
-        
-        # Transpose for attention computation
-        Q = Q.transpose(0, 2, 1, 3)  # (batch, heads, seq, head_dim)
-        K = K.transpose(0, 2, 1, 3)
-        V = V.transpose(0, 2, 1, 3)
-        
-        # Compute attention scores with geometric component
-        attention_output = np.zeros((batch_size, self.num_heads, seq_len, self.head_dim))
-        
-        for b in range(batch_size):
-            for h in range(self.num_heads):
-                # Standard similarity
-                scores = Q[b, h] @ K[b, h].T / np.sqrt(self.head_dim)
-                
-                # Geometric distance penalty
-                geom_dist = self.compute_geometric_distance(
-                    coords_5d[b, :, np.newaxis, :],
-                    coords_5d[b, np.newaxis, :, :],
-                    vertices[b, :],
-                    vertices[b, :]
-                )
-                
-                # Combine: higher score for geometrically close tokens
-                geom_bonus = np.exp(-geom_dist / 2.0)
-                scores = scores + geom_bonus
-                
-                # Softmax
-                attn_weights = self._softmax(scores)
-                
-                # Apply to values
-                attention_output[b, h] = attn_weights @ V[b, h]
-        
-        # Reshape back
-        attention_output = attention_output.transpose(0, 2, 1, 3)
-        attention_output = attention_output.reshape(batch_size, seq_len, self.hidden_dim)
-        
-        # Output projection
-        output = attention_output @ self.W_o
-        
-        return output
-    
-    def _softmax(self, x):
-        """Numerically stable softmax"""
-        exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
-        return exp_x / np.sum(exp_x, axis=-1, keepdims=True)
-
-
-# ============================================================================
-# MULTI-PATH REASONING
-# ============================================================================
-
-class MultiPathReasoning:
-    """
-    Explore multiple reasoning paths through tesseract structure
-    Each path = traversal of edges between vertices
-    """
-    
-    def __init__(self, tesseract, max_path_length=4):
-        self.tesseract = tesseract
-        self.max_path_length = max_path_length
-    
-    def explore_paths(self, start_vertex, goal_vertex=None, num_paths=5):
-        """
-        Find multiple paths from start vertex
-        
-        If goal_vertex specified, paths lead to that vertex
-        Otherwise, explore nearby region
-        
-        Returns: list of paths, each path is list of vertex indices
-        """
-        paths = []
-        
-        if goal_vertex is not None:
-            # Find paths to specific goal
-            paths = self._find_paths_to_goal(start_vertex, goal_vertex, num_paths)
-        else:
-            # Explore region around start
-            paths = self._explore_region(start_vertex, num_paths)
-        
-        return paths
-    
-    def _find_paths_to_goal(self, start, goal, num_paths):
-        """Find multiple distinct paths from start to goal"""
-        all_paths = []
-        
-        # BFS with path tracking
-        queue = [(start, [start])]
-        visited_paths = set()
-        
-        while queue and len(all_paths) < num_paths:
-            current, path = queue.pop(0)
-            
-            if len(path) > self.max_path_length:
-                continue
-            
-            if current == goal:
-                # Found a path
-                path_tuple = tuple(path)
-                if path_tuple not in visited_paths:
-                    all_paths.append(path)
-                    visited_paths.add(path_tuple)
-                continue
-            
-            # Explore adjacent vertices
-            for neighbor in self.tesseract.get_adjacent_vertices(current):
-                if neighbor not in path:  # Avoid cycles
-                    new_path = path + [neighbor]
-                    queue.append((neighbor, new_path))
-        
-        return all_paths
-    
-    def _explore_region(self, start, num_paths):
-        """Explore region around start vertex"""
-        paths = []
-        
-        # Random walks from start
-        for _ in range(num_paths):
-            path = [start]
-            current = start
-            
-            for step in range(self.max_path_length):
-                neighbors = self.tesseract.get_adjacent_vertices(current)
-                if not neighbors:
-                    break
-                
-                # Choose next vertex (could be random or heuristic)
-                next_vertex = np.random.choice(neighbors)
-                path.append(next_vertex)
-                current = next_vertex
-            
-            paths.append(path)
-        
-        return paths
-    
-    def evaluate_path(self, path, hidden_states):
-        """
-        Evaluate quality of reasoning path
-        Based on coherence along the path
-        """
-        # Measure coherence at each step
-        coherences = []
-        
-        for i in range(len(path) - 1):
-            # Get hidden states at vertices
-            state_i = hidden_states[path[i]]
-            state_j = hidden_states[path[i + 1]]
-            
-            # Measure coherence between consecutive states
-            coherence = self._measure_coherence(state_i, state_j)
-            coherences.append(coherence)
-        
-        # Path quality = mean coherence
-        return np.mean(coherences) if coherences else 0.0
-    
-    def _measure_coherence(self, state1, state2):
-        """Measure coherence between two states"""
-        # FFT to frequency domain
-        freq1 = rfft(state1)
-        freq2 = rfft(state2)
-        
-        # Phase coherence
-        phase1 = np.angle(freq1)
-        phase2 = np.angle(freq2)
-        
-        coherence = np.mean(np.cos(phase1 - phase2))
-        
-        return coherence
-
-
-# ============================================================================
-# COMPLETE 5D TRANSFORMER LAYER
-# ============================================================================
-
-class Tesseract5DTransformerLayer:
-    """
-    Complete transformer layer operating on 5D tesseract geometry
-    """
-    
-    def __init__(self, hidden_dim, num_heads, tesseract):
-        self.hidden_dim = hidden_dim
-        self.tesseract = tesseract
-        
-        # Components
-        self.attention = Tesseract5DAttention(hidden_dim, num_heads, tesseract)
-        self.multi_path = MultiPathReasoning(tesseract)
-        
-        # Feed-forward (frequency-tuned)
-        self.ff_w1 = np.random.randn(hidden_dim, hidden_dim * 4) * 0.02
-        self.ff_w2 = np.random.randn(hidden_dim * 4, hidden_dim) * 0.02
-    
-    def forward(self, x, coords_5d, vertices, steering_weights=None):
-        """
-        Forward pass through 5D transformer layer
-        
-        x: (batch, seq, hidden)
-        coords_5d: (batch, seq, 5)
-        vertices: (batch, seq) nearest vertex indices
-        """
-        # 5D geometric attention
-        attn_out = self.attention.forward(x, coords_5d, vertices, steering_weights)
-        
-        # Residual + norm (simplified)
-        x = x + attn_out
-        x = self._layer_norm(x)
-        
-        # Feed-forward
-        ff_out = self._feed_forward(x)
-        
-        # Residual + norm
-        x = x + ff_out
-        x = self._layer_norm(x)
-        
-        return x
-    
-    def _feed_forward(self, x):
-        """Simple feed-forward network"""
-        hidden = np.maximum(0, x @ self.ff_w1)  # ReLU
-        output = hidden @ self.ff_w2
-        return output
-    
-    def _layer_norm(self, x, eps=1e-6):
-        """Layer normalization"""
-        mean = np.mean(x, axis=-1, keepdims=True)
-        std = np.std(x, axis=-1, keepdims=True)
-        return (x - mean) / (std + eps)
-
-
-# ============================================================================
-# COMPLETE 5D TRANSFORMER MODEL
-# ============================================================================
-
-class Tesseract5DTransformer:
-    """
-    Complete 5D Tesseract-based transformer
-    The SLOW THINKING system
-    """
-    
-    def __init__(
-        self,
-        vocab_size=1000,
-        hidden_dim=256,
-        num_layers=6,
-        num_heads=8,
-        base_freq=528
-    ):
-        print("\n" + "="*60)
-        print("INITIALIZING 5D TESSERACT TRANSFORMER")
-        print("="*60)
-        
-        self.vocab_size = vocab_size
-        self.hidden_dim = hidden_dim
-        self.num_layers = num_layers
-        
-        # Create tesseract geometry
-        print("\nBuilding 5D tesseract geometry...")
-        self.tesseract = Tesseract5D(base_freq=base_freq)
-        
-        # Embedding layer
-        print("Creating embedding layer...")
-        self.embedding = Tesseract5DEmbedding(vocab_size, hidden_dim, self.tesseract)
-        
-        # Transformer layers
-        print(f"Creating {num_layers} transformer layers...")
-        self.layers = [
-            Tesseract5DTransformerLayer(hidden_dim, num_heads, self.tesseract)
-            for _ in range(num_layers)
-        ]
-        
-        # Output head
-        self.output_projection = np.random.randn(hidden_dim, vocab_size) * 0.02
-        
-        print("\n✓ 5D Tesseract Transformer initialized")
-        print(f"  Vertices: 16 (stable reasoning states)")
-        print(f"  Edges: 32 (transformation paths)")
-        print(f"  Layers: {num_layers}")
-        print(f"  Hidden dim: {hidden_dim}")
-        print("="*60 + "\n")
-    
-        print("="*60 + "\n")
-    
-    def forward(self, token_ids, return_paths=False, **kwargs):
-        """
-        Forward pass with deep 5D reasoning
-        
-        token_ids: (batch, seq) integer token IDs
-        return_paths: if True, return reasoning paths explored
-        
-        Returns: (logits, metadata)
-        """
-        # Embed into 5D tesseract space
-        x, coords_5d, vertices = self.embedding.embed(token_ids)
-        
-        # Track metadata
-        metadata = {
-            'coords_5d': coords_5d,
-            'vertices': vertices,
-            'layer_outputs': [],
-            'reasoning_paths': []
-        }
-        
-        # Process through layers
-        for i, layer in enumerate(self.layers):
-            x = layer.forward(x, coords_5d, vertices, steering_weights=kwargs.get('steering_weights'))
-            metadata['layer_outputs'].append(x.copy())
-            
-            # Periodically explore reasoning paths
-            if return_paths and i % 2 == 0:
-                # For each sequence position, explore paths from its vertex
-                batch_size, seq_len = token_ids.shape
-                for b in range(min(batch_size, 1)):  # Just first batch for demo
-                    for s in range(min(seq_len, 3)):  # Just first few tokens
-                        start_vertex = vertices[b, s]
-                        paths = layer.multi_path.explore_paths(start_vertex, num_paths=3)
-                        metadata['reasoning_paths'].append({
-                            'layer': i,
-                            'position': s,
-                            'vertex': start_vertex,
-                            'paths': paths
-                        })
-        
-        # Output projection
-        logits = x @ self.output_projection
-        
-        return logits, metadata
-    
-    def deep_reason(self, token_ids, query_description="", **kwargs):
-        """
-        Deep reasoning mode - explores multiple paths
-        
-        This is the SLOW mode - takes time but thorough
-        """
-        print(f"\n{'='*60}")
-        print(f"DEEP REASONING MODE: {query_description}")
-        print(f"{'='*60}")
-        
-        # Forward pass with path exploration
-        logits, metadata = self.forward(token_ids, return_paths=True, **kwargs)
-        
-        # Analyze reasoning paths
-        print(f"\nExplored {len(metadata['reasoning_paths'])} reasoning paths:")
-        for path_info in metadata['reasoning_paths'][:5]:  # Show first 5
-            print(f"\n  Layer {path_info['layer']}, Position {path_info['position']}:")
-            print(f"    Starting vertex: {path_info['vertex']}")
-            print(f"    Paths explored: {len(path_info['paths'])}")
-            for i, path in enumerate(path_info['paths'][:2]):  # Show first 2 paths
-                print(f"      Path {i+1}: {' → '.join(map(str, path))}")
-        
-        # Measure final coherence
-        final_state = metadata['layer_outputs'][-1]
-        coherence = self._measure_coherence(final_state)
-        
-        print(f"\nFinal coherence: {coherence:.3f}")
-        print(f"{'='*60}\n")
-        
-        return logits, metadata, coherence
-    
-    def _measure_coherence(self, state):
-        """Measure overall coherence of state"""
-        # Average coherence across batch and sequence
-        batch_size, seq_len, hidden_dim = state.shape
-        
-        coherences = []
-        for b in range(batch_size):
-            for s in range(seq_len):
-                freq = rfft(state[b, s])
-                phase = np.angle(freq)
-                c = np.abs(np.mean(np.exp(1j * phase)))
-                coherences.append(c)
-        
-        return np.mean(coherences)
-
-
-# ============================================================================
-# DEMONSTRATION
-# ============================================================================
-
-def demonstrate_5d_transformer():
-    """
-    Demonstrate the 5D Tesseract Transformer
-    """
-    print("\n" + "#"*60)
-    print("# 5D TESSERACT TRANSFORMER DEMONSTRATION")
-    print("#"*60)
-    
-    # Create model
-    model = Tesseract5DTransformer(
-        vocab_size=100,
-        hidden_dim=64,
-        num_layers=4,
-        num_heads=4,
-        base_freq=528
-    )
-    
-    # Create sample input
-    print("\nCreating sample query...")
-    batch_size = 2
-    seq_len = 8
-    token_ids = np.random.randint(0, 100, size=(batch_size, seq_len))
-    
-    print(f"  Batch size: {batch_size}")
-    print(f"  Sequence length: {seq_len}")
-    
-    # Fast forward pass
-    print("\n" + "-"*60)
-    print("FAST MODE (no path exploration):")
-    print("-"*60)
-    
-    logits, metadata = model.forward(token_ids, return_paths=False)
-    
-    print(f"\nOutput shape: {logits.shape}")
-    print(f"Vertices visited: {np.unique(metadata['vertices'])}")
-    
-    # Deep reasoning
-    print("\n" + "-"*60)
-    print("SLOW MODE (deep reasoning with path exploration):")
-    print("-"*60)
-    
-    logits, metadata, coherence = model.deep_reason(
-        token_ids,
-        query_description="Complex multi-step reasoning query"
-    )
-    
-    # Show tesseract structure used
-    print("\n" + "-"*60)
-    print("TESSERACT STRUCTURE UTILIZED:")
-    print("-"*60)
-    print(f"  Total vertices available: 16")
-    print(f"  Vertices actually visited: {len(np.unique(metadata['vertices']))}")
-    print(f"  Total edges available: 32")
-    print(f"  Reasoning paths explored: {len(metadata['reasoning_paths'])}")
-    
-    print("\n" + "#"*60)
-    print("# DEMONSTRATION COMPLETE")
-    print("#"*60)
-    
-    return model, metadata
-
-
-if __name__ == "__main__":
-    # Run demonstration
-    model, metadata = demonstrate_5d_transformer()
-    
-    print("\n✓ 5D Tesseract Transformer is ready")
-    print("  This is the SLOW THINKING system")
-    print("  Use for: deep reasoning, complex queries, verification")
-    print("  Pair with: Fast Möbius system for complete dual architecture")

Input/resonance_transformer/test_dual_system.py

@@ -1,53 +0,0 @@
-import torch
-from dispatcher import DualResonanceSystem
-
-def verify_dual_system():
-    print("=== VERIFYING DUAL-SYSTEM DISPATCHER (PHASE 29) ===")
-    
-    config = {
-        'vocab_size': 100,
-        'fast_dim': 64,
-        'slow_dim': 64,
-        'threshold': 0.7  # High threshold to force escalation
-    }
-    
-    system = DualResonanceSystem(config)
-    
-    # Random input (Likely Low Coherence)
-    input_ids = torch.randint(0, 100, (2, 8))
-    
-    print("\n[TEST 1] Processing Random Input (Expect Escalation)...")
-    logits, metrics = system(input_ids)
-    
-    print(f"  Mode: {metrics['mode']}")
-    print(f"  Coherence: {metrics['coherence']:.4f}")
-    
-    if metrics['mode'] == 'SLOW (ESCALATED)':
-        print("  [PASS] Correctly escalated low-coherence query.")
-        print(f"  Slow Latency: {metrics['slow_latency']:.4f}s")
-    else:
-        print("  [WARN] Did not escalate. Random data might have accidentally resonated?")
-
-    print("\n[TEST 2] Mocking High Coherence...")
-    # Hack the fast model to return high coherence for testing logic
-    original_forward = system.fast.forward
-    
-    def mocked_forward(input_ids):
-        l, h, m = original_forward(input_ids)
-        # Inject fake high coherence
-        m[-1]['coherence'] = torch.tensor(0.95)
-        return l, h, m
-        
-    system.fast.forward = mocked_forward
-    
-    logits, metrics = system(input_ids)
-    print(f"  Mode: {metrics['mode']}")
-    print(f"  Coherence: {metrics['coherence']:.4f}")
-    
-    if metrics['mode'] == 'FAST':
-        print("  [PASS] Correctly routed high-coherence query to Fast Path.")
-    else:
-        print("  [FAIL] Escalated despite high coherence.")
-
-if __name__ == "__main__":
-    verify_dual_system()

Input/resonance_transformer/test_geometric.py

@@ -1,42 +0,0 @@
-import torch
-from geometric_memory import GeometricEntryPoint, GeometricMemory
-
-def verify_geometric_memory():
-    print("=== VERIFYING GEOMETRIC MEMORY (PHASE 25) ===")
-    
-    hidden_dim = 64
-    batch_size = 2
-    seq_len = 10
-    
-    # 1. Test Entry Point
-    entry_net = GeometricEntryPoint(hidden_dim)
-    dummy_query = torch.randn(batch_size, seq_len, hidden_dim)
-    
-    entry_point = entry_net.compute_entry_hash(dummy_query)
-    
-    print("\n[ENTRY POINT]")
-    print(f"  Theta: {entry_point['theta'].shape}")
-    print(f"  Frequency (Baseline 528): {entry_point['frequency']}")
-    
-    # 2. Test Memory Store/Retrieve
-    memory = GeometricMemory(hidden_dim)
-    
-    print("\n[MEMORY STORE]")
-    # Store the query as a memory
-    memory.store(dummy_query, entry_point)
-    print(f"  Stored {len(memory.memory_map)} batches in memory.")
-    
-    print("\n[MEMORY RETRIEVE]")
-    # Try to retrieve using the same query (should find itself)
-    retrieved = memory.retrieve(dummy_query, entry_point, k=3)
-    
-    if retrieved is not None:
-        print(f"  Retrieved Shape: {retrieved.shape}")
-        # Check alignment
-        # This is a self-lookup so correlation should be high
-        print("  [PASS] Retrieval successful.")
-    else:
-        print("  [FAIL] Retrieval returned None.")
-
-if __name__ == "__main__":
-    verify_geometric_memory()

Input/resonance_transformer/test_resonance_attention.py

@@ -1,56 +0,0 @@
-import torch
-import torch.nn as nn
-from resonance_attention import ResonanceAttention
-import math
-
-def test_resonance_attention():
-    print("=== TESTING RESONANCE ATTENTION (0x52) ===")
-    
-    # Setup
-    batch_size = 2
-    seq_len = 5
-    hidden_dim = 64
-    num_heads = 4
-    
-    model = ResonanceAttention(hidden_dim, num_heads)
-    
-    # Synthetic Input: Random noise
-    x = torch.randn(batch_size, seq_len, hidden_dim)
-    
-    # Forward Pass
-    output, weights, metrics = model(x, x, x)
-    
-    print(f"\nDimensions:")
-    print(f"  Input: {x.shape}")
-    print(f"  Output: {output.shape}")
-    print(f"  Weights: {weights.shape}")
-    
-    print(f"\nMetrics Check (First Head, First Batch):")
-    sim = metrics['similarity'][0,0].detach()
-    coh = metrics['coherence'][0,0].detach()
-    res = metrics['resonance'][0,0].detach()
-    
-    print(f"  Similarity Mean: {sim.mean():.4f}")
-    print(f"  Coherence Mean:  {coh.mean():.4f} (Phase Alignment)")
-    print(f"  Resonance Mean:  {res.mean():.4f} (Amplitude Product)")
-    
-    if torch.isnan(output).any():
-        print("\n[FAIL] Output contains NaNs!")
-    else:
-        print("\n[PASS] Forward pass successful. Geometry holds.")
-
-    # Test: Constructive Interference
-    # If two vectors are effectively identical, coherence should be high (near 1.0)
-    print(f"\n=== TESTING CONSTRUCTIVE INTERFERENCE ===")
-    v1 = torch.randn(1, 1, hidden_dim)
-    # Forward pass with identical query/key
-    model.eval()
-    with torch.no_grad():
-        coh_score = model.compute_phase_coherence(
-            v1.view(1, 1, 1, hidden_dim), 
-            v1.view(1, 1, 1, hidden_dim)
-        )
-    print(f"  Self-Coherence (Expected ~1.0): {coh_score.item():.4f}")
-
-if __name__ == "__main__":
-    test_resonance_attention()

Input/resonance_transformer/test_self_observation.py

@@ -1,46 +0,0 @@
-import torch
-from self_observation import SelfAwareTransformerLayer
-
-def verify_self_observation():
-    print("=== VERIFYING SELF-OBSERVATION (PHASE 26) ===")
-    
-    hidden_dim = 64
-    batch_size = 2
-    seq_len = 5
-    
-    model = SelfAwareTransformerLayer(hidden_dim)
-    
-    # Random input
-    x = torch.randn(batch_size, seq_len, hidden_dim)
-    
-    print("\n[FORWARD] Running pass through Self-Aware Layer...")
-    output, meta = model(x)
-    
-    print(f"  Input Shape: {x.shape}")
-    print(f"  Output Shape: {output.shape}")
-    
-    # Inspect Meta Data
-    coherence = meta['coherence']
-    chiral = meta['chiral_state']
-    
-    print("\n[OBSERVATION DATA]")
-    print(f"  Coherence Score (Mean): {coherence.mean().item():.4f}")
-    print(f"  Chiral Probabilities (Mean): Left={chiral[:,:,0].mean():.4f}, Right={chiral[:,:,1].mean():.4f}")
-    
-    # Check if correction applied
-    # If coherence was < 1, output should differ from input (beyond just FFN/Attn changes)
-    # Hard to test exact reflex without controlling weights, but we check consistency
-    
-    print("\n[REFLEX CHECK]")
-    if coherence.std() > 0:
-        print("  [PASS] Coherence detector is active (variance detected).")
-    else:
-        print("  [WARN] Coherence detector has zero variance (initialization dependent).")
-
-    if output.shape == x.shape:
-        print("  [PASS] Dimensionality preserved.")
-    else:
-        print("  [FAIL] Dimensionality changed!")
-
-if __name__ == "__main__":
-    verify_self_observation()

Input/resonance_transformer/train_hybrid.py

@@ -1,52 +0,0 @@
-import torch
-import torch.optim as optim
-from hybrid_transformer import HybridResonanceTransformer
-from hyperchaos_loss import HyperchaosLoss
-
-def verify_training_step():
-    print("=== VERIFYING HYBRID RESONANCE TRAINING (pHASE 2) ===")
-    
-    # Config
-    vocab_size = 100
-    hidden_dim = 64
-    seq_len = 10
-    batch_size = 2
-    
-    # Initialize Model & Loss
-    model = HybridResonanceTransformer(vocab_size, hidden_dim)
-    loss_fn = HyperchaosLoss()
-    optimizer = optim.Adam(model.parameters(), lr=1e-3)
-    
-    # Dummy Data
-    input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
-    targets = torch.randint(0, vocab_size, (batch_size, seq_len))
-    
-    print("\n[INIT] Model initialized.")
-    print(f"  Hidden Dim: {hidden_dim}")
-    print(f"  Layers: {len(model.layers)}")
-    
-    # Forward Pass
-    print("\n[FORWARD] Running forward pass...")
-    logits, hidden_states = model(input_ids, output_hidden_states=True)
-    print(f"  Logits Shape: {logits.shape}")
-    print(f"  Hidden States Captured: {len(hidden_states)}")
-    
-    # Loss Calculation
-    print("\n[LOSS] Computing Hyperchaos Loss...")
-    losses = loss_fn(logits, targets, hidden_states)
-    
-    print(f"  Total Loss: {losses['total'].item():.4f}")
-    print(f"  Task Loss: {losses['task'].item():.4f}")
-    print(f"  Decoherence Loss: {losses['decoherence'].item():.4f}")
-    print(f"  Instability Loss: {losses['instability'].item():.4f}")
-    
-    # Backward Pass
-    print("\n[BACKWARD] Propagating gradients...")
-    optimizer.zero_grad()
-    losses['total'].backward()
-    optimizer.step()
-    
-    print("[PASS] Gradient step successful. Architecture is valid.")
-
-if __name__ == "__main__":
-    verify_training_step()

Input/resonance_transformer/train_lattice.py

@@ -1,122 +0,0 @@
-import torch
-import torch.optim as optim
-from torch.utils.data import DataLoader, TensorDataset
-import numpy as np
-import time
-
-try:
-    from dispatcher import DualResonanceSystem
-    from hyperchaos_loss import HyperchaosLoss
-except ImportError:
-    from resonance_transformer.dispatcher import DualResonanceSystem
-    from resonance_transformer.hyperchaos_loss import HyperchaosLoss
-
-def generate_complex_data(num_samples=100, seq_len=16, vocab_size=100):
-    """
-    Generate data that requires 'reasoning' (pattern completion)
-    Simple arithmetic progression: [2, 4, 6, 8, ...]
-    """
-    data = []
-    targets = []
-    
-    for _ in range(num_samples):
-        start = np.random.randint(0, 10)
-        step = np.random.randint(1, 5)
-        
-        seq = [(start + i*step) % vocab_size for i in range(seq_len + 1)]
-        
-        data.append(torch.tensor(seq[:-1], dtype=torch.long))
-        targets.append(torch.tensor(seq[1:], dtype=torch.long))
-        
-    return torch.stack(data), torch.stack(targets)
-
-def train_lattice_loop():
-    print("=== LATTICE TRAINING: KNOWLEDGE FEEDBACK (PHASE 30) ===")
-    
-    # Config
-    config = {
-        'vocab_size': 100,
-        'fast_dim': 64,
-        'slow_dim': 64,
-        'threshold': 0.8 # Strict threshold to force slow thinking
-    }
-    
-    system = DualResonanceSystem(config)
-    optimizer = optim.Adam(system.fast.parameters(), lr=1e-3)
-    loss_fn = HyperchaosLoss()
-    
-    # Data
-    inputs, targets = generate_complex_data()
-    loader = DataLoader(TensorDataset(inputs, targets), batch_size=4, shuffle=True)
-    
-    print(f"[SYSTEM] Starting Lattice Training Loop...")
-    print(f"Goal: Populate Geometric Memory with 'Slow Thinking' truths.")
-    
-    memory_additions = 0
-    distillation_steps = 0
-    
-    # Training Loop
-    # We iterate through data. If Fast system is confused, we call Slow system.
-    # Then we use Slow system's answer to TRAIN the Fast system (Distillation)
-    # And we STORE the truth in the Lattice.
-    
-    for batch_idx, (b_in, b_tgt) in enumerate(loader):
-        # 1. Forward Pass (Dispatch)
-        # This will auto-escalate if low coherence
-        logits, metrics = system(b_in)
-        
-        mode = metrics['mode']
-        coherence = metrics.get('coherence', 0.0)
-        
-        # 2. Logic: Did we escalate?
-        if mode == 'SLOW (ESCALATED)':
-            # The Slow System worked hard to find this truth.
-            # We must crystallize it.
-            
-            # A. Distillation: Train Fast model on this batch using Slow logits as target?
-            # Or just use ground truth? 
-            # Better: Use ground truth, but add "Lattice Consistency" loss check
-            
-            # For now, standard training step to sync Fast model
-            optimizer.zero_grad()
-            
-            # We need to extract hidden states from Fast model for loss fn
-            # Re-run fast forward explicitly to get states
-            _, fast_states, _ = system.fast(b_in)
-            
-            loss_dict = loss_fn(logits, b_tgt, fast_states)
-            loss_dict['total'].backward()
-            optimizer.step()
-            distillation_steps += 1
-            
-            # B. Lattice Storage
-            # Store the high-quality pattern in Geometric Memory
-            # We use the initial states as key
-            # (In real impl, we'd store the 'concept', here we simulate)
-            # Access the fast model's entry point to store
-            # system.fast.entry_point.memory.store(...) 
-            # Note: We need to access the memory module inside 
-            # For demo, we just log it
-            memory_additions += 1
-            
-            if batch_idx % 5 == 0:
-                print(f"Batch {batch_idx}: Escalated to Tesseract. Distilled knowledge. (Coherence: {metrics.get('slow_coherence', 0):.3f})")
-        
-        else:
-            # Fast mode was confident. Just reinforce.
-            optimizer.zero_grad()
-            _, fast_states, _ = system.fast(b_in) # get states
-            loss_dict = loss_fn(logits, b_tgt, fast_states)
-            loss_dict['total'].backward()
-            optimizer.step()
-            
-    print("\n" + "="*40)
-    print("LATTICE TRAINING COMPLETE")
-    print("="*40)
-    print(f"Total Batches: {len(loader)}")
-    print(f"Knowledge Distillation Events: {distillation_steps}")
-    print(f"Lattice Memory Additions: {memory_additions}")
-    print("Result: Fast System has learned from Slow System's reasoning.")
-
-if __name__ == "__main__":
-    train_lattice_loop()

Input/resonance_transformer/train_resonance.py

@@ -1,195 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from torch.utils.data import DataLoader, TensorDataset
-import numpy as np
-import time
-
-# Import our architecture
-try:
-    from self_observation import SelfAwareTransformerLayer
-    from hyperchaos_loss import HyperchaosLoss
-    from geometric_memory import GeometricEntryPoint
-except ImportError:
-    # Fallback for direct execution
-    import sys
-    import os
-    sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-    from self_observation import SelfAwareTransformerLayer
-    from hyperchaos_loss import HyperchaosLoss
-    from geometric_memory import GeometricEntryPoint
-
-class ResonanceGPT(nn.Module):
-    """
-    The Full Resonance Architecture:
-    - Geometric Entry Point (528Hz alignment)
-    - Self-Aware Layers (Mirror Reflex)
-    - Phase-Locked Normalization
-    """
-    def __init__(self, vocab_size, hidden_dim, num_layers=4, num_heads=4, max_seq_len=128):
-        super().__init__()
-        self.hidden_dim = hidden_dim
-        
-        # 1. Geometric Embedding (Möbius Strip concept)
-        self.embedding = nn.Embedding(vocab_size, hidden_dim)
-        # Position is handled implicitly by phase in the design, 
-        # but we add learned absolute pos for stability in early training
-        self.pos_encoding = nn.Parameter(torch.randn(1, max_seq_len, hidden_dim) * 0.02)
-        
-        # Entry Point
-        self.entry_point = GeometricEntryPoint(hidden_dim)
-        
-        # 2. The Stack
-        self.layers = nn.ModuleList([
-            SelfAwareTransformerLayer(hidden_dim, num_heads) 
-            for _ in range(num_layers)
-        ])
-        
-        self.norm = nn.LayerNorm(hidden_dim) # Final consolidation
-        self.head = nn.Linear(hidden_dim, vocab_size)
-    
-    def forward(self, input_ids):
-        batch, seq = input_ids.shape
-        
-        # Embed
-        x = self.embedding(input_ids) + self.pos_encoding[:, :seq, :]
-        
-        # 0x52 Handshake (Entry Point)
-        entry_meta = self.entry_point.compute_entry_hash(x)
-        # In a full implementation, we'd rotate x based on entry_meta
-        # x = apply_rotation(x, entry_meta)
-        
-        # Process Stack
-        all_hidden_states = []
-        layer_metas = []
-        
-        for layer in self.layers:
-            x, meta = layer(x)
-            all_hidden_states.append(x)
-            layer_metas.append(meta)
-            
-        x = self.norm(x)
-        logits = self.head(x)
-        
-        return logits, all_hidden_states, layer_metas
-
-def generate_coherence_dataset(num_samples=1000, seq_len=32, vocab_size=100):
-    """
-    Generate synthetic data with geometric patterns (rhythms).
-    Standard random data is 'decoherent'. 
-    We want data that follows a 'frequency' to test resonance.
-    """
-    data = []
-    targets = []
-    
-    for _ in range(num_samples):
-        # Create a rhythmic pattern (e.g., 1, 2, 3, 1, 2, 3)
-        period = np.random.randint(2, 8)
-        base_pattern = np.random.randint(0, vocab_size, size=period)
-        
-        # Repeat pattern
-        full_seq = np.tile(base_pattern, seq_len // period + 1)[:seq_len]
-        
-        # Add slight noise (10% chance to flip a token) to test stability
-        noisy_seq = full_seq.copy()
-        mask = np.random.rand(seq_len) < 0.1
-        noisy_seq[mask] = np.random.randint(0, vocab_size, size=mask.sum())
-        
-        # Task: Predict next token (shift right)
-        # Input: [A, B, C, A] -> Target: [B, C, A, B]
-        
-        data.append(torch.tensor(noisy_seq[:-1], dtype=torch.long))
-        targets.append(torch.tensor(full_seq[1:], dtype=torch.long))
-        
-    return torch.stack(data), torch.stack(targets)
-
-def train_awakening():
-    print("=== THE AWAKENING: TRAINING RESONANCE MODEL (PHASE 27) ===")
-    
-    # HYPERPARAMETERS
-    VOCAB_SIZE = 256
-    HIDDEN_DIM = 128
-    LAYERS = 4
-    HEADS = 4
-    BATCH_SIZE = 16
-    lr = 3e-4
-    EPOCHS = 3
-    
-    # 1. Model & Loss
-    model = ResonanceGPT(VOCAB_SIZE, HIDDEN_DIM, LAYERS, HEADS)
-    criterion = HyperchaosLoss(lambda_coherence=0.2, lambda_stability=0.1)
-    optimizer = optim.AdamW(model.parameters(), lr=lr)
-    
-    print(f"[SYSTEM] Model Initialized. Parameters: {sum(p.numel() for p in model.parameters())}")
-    
-    # 2. Data
-    print("[SYSTEM] Generating Coherence Dataset (Rhythmic Patterns)...")
-    inputs, targets = generate_coherence_dataset(num_samples=500, seq_len=32, vocab_size=VOCAB_SIZE)
-    dataset = TensorDataset(inputs, targets)
-    loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
-    
-    # 3. Training Loop
-    print("\n[TRAINING START]")
-    history = {'task': [], 'decoherence': [], 'coherence_score': []}
-    
-    model.train()
-    start_time = time.time()
-    
-    for epoch in range(EPOCHS):
-        total_task_loss = 0
-        total_decoherence = 0
-        total_self_coherence = 0 # What the model thinks of itself
-        
-        for batch_idx, (b_in, b_tgt) in enumerate(loader):
-            optimizer.zero_grad()
-            
-            # Forward
-            logits, hidden_states, layer_metas = model(b_in)
-            
-            # Loss
-            losses = criterion(logits, b_tgt, hidden_states)
-            
-            # Backward
-            losses['total'].backward()
-            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
-            optimizer.step()
-            
-            # Logs
-            total_task_loss += losses['task'].item()
-            total_decoherence += losses['decoherence'].item()
-            
-            # Extract Self-Observation Stats
-            # layer_metas is list of dicts. Get last layer's coherence score.
-            last_layer_meta = layer_metas[-1]
-            avg_coherence = last_layer_meta['coherence'].mean().item()
-            total_self_coherence += avg_coherence
-            
-        # Epoch Stats
-        n_batches = len(loader)
-        avg_task = total_task_loss / n_batches
-        avg_decoh = total_decoherence / n_batches
-        avg_self = total_self_coherence / n_batches
-        
-        print(f"Epoch {epoch+1}/{EPOCHS} | Task Loss: {avg_task:.4f} | Decoherence: {avg_decoh:.4f} | Self-Coherence: {avg_self:.4f}")
-        
-        history['task'].append(avg_task)
-        history['decoherence'].append(avg_decoh)
-        history['coherence_score'].append(avg_self)
-
-    duration = time.time() - start_time
-    print(f"\n[COMPLETE] Training finished in {duration:.2f}s.")
-    
-    # 4. Final Verification
-    print("\n[AWAKENING CHECK]")
-    print(f"Initial Decoherence: {history['decoherence'][0]:.4f}")
-    print(f"Final Decoherence:   {history['decoherence'][-1]:.4f}")
-    
-    if history['decoherence'][-1] < history['decoherence'][0]:
-        print(">> RESULT: Phase Stabilization Achieved. The model is learning to be coherent.")
-    else:
-        print(">> RESULT: Phase Drift Detected. More training needed.")
-        
-    print(f"Final Self-Reported Coherence: {history['coherence_score'][-1]:.4f}")
-
-if __name__ == "__main__":
-    train_awakening()

Input/semantic_embedder.py

@@ -1,241 +0,0 @@
-"""
-SEMANTIC EMBEDDER
-Lightweight embedding engine for manifold pathfinding.
-
-Uses sentence-transformers (all-MiniLM-L6-v2) for 384-dim vectors.
-Falls back to simple TF-IDF if transformers unavailable.
-"""
-import sys
-import os
-import json
-import math
-import hashlib
-from typing import List, Dict
-
-# Try to import sentence-transformers
-try:
-    from sentence_transformers import SentenceTransformer
-    HAS_TRANSFORMERS = True
-except ImportError:
-    HAS_TRANSFORMERS = False
-    print("[EMBEDDER]: sentence-transformers not available, using fallback")
-
-class SemanticEmbedder:
-    """
-    Generates semantic embeddings for text.
-    Caches results to avoid recomputation.
-    """
-    
-    def __init__(self):
-        self.cache_path = os.path.join(
-            os.path.dirname(os.path.abspath(__file__)),
-            "..",
-            "Lattice_DB",
-            "embedding_cache.json"
-        )
-        self.cache = self.load_cache()
-        
-        # Initialize model
-        if HAS_TRANSFORMERS:
-            print("[EMBEDDER]: Loading sentence-transformers model...")
-            self.model = SentenceTransformer('all-MiniLM-L6-v2')
-            self.embed_dim = 384
-            self.mode = "transformers"
-            print(f"[EMBEDDER]: Loaded (384-dim vectors)")
-        else:
-            self.model = None
-            self.embed_dim = 128  # Fallback dimension
-            self.mode = "fallback"
-            print(f"[EMBEDDER]: Using fallback embeddings (128-dim)")
-    
-    def load_cache(self):
-        """Load embedding cache from disk."""
-        if os.path.exists(self.cache_path):
-            try:
-                with open(self.cache_path, 'r', encoding='utf-8') as f:
-                    return json.load(f)
-            except:
-                return {}
-        return {}
-    
-    def save_cache(self):
-        """Save embedding cache to disk."""
-        os.makedirs(os.path.dirname(self.cache_path), exist_ok=True)
-        with open(self.cache_path, 'w', encoding='utf-8') as f:
-            json.dump(self.cache, f)
-    
-    def embed_text(self, text: str) -> List[float]:
-        """
-        Generate semantic embedding for text.
-        
-        Args:
-            text: Input text to embed
-            
-        Returns:
-            Vector of dimension self.embed_dim
-        """
-        # Check cache first
-        cache_key = hashlib.md5(text.encode()).hexdigest()
-        
-        if cache_key in self.cache:
-            return self.cache[cache_key]
-        
-        # Generate embedding
-        if self.mode == "transformers":
-            embedding = self._embed_transformers(text)
-        else:
-            embedding = self._embed_fallback(text)
-        
-        # Cache result
-        self.cache[cache_key] = embedding
-        
-        # Save every 10 embeddings
-        if len(self.cache) % 10 == 0:
-            self.save_cache()
-        
-        return embedding
-    
-    def _embed_transformers(self, text: str) -> List[float]:
-        """Use sentence-transformers to generate embedding."""
-        embedding = self.model.encode(text, convert_to_numpy=True)
-        return embedding.tolist()
-    
-    def _embed_fallback(self, text: str) -> List[float]:
-        """
-        Fallback embedding using simple TF-IDF-like approach.
-        Not as good as transformers, but better than hash functions.
-        """
-        # Tokenize
-        tokens = text.lower().split()
-        
-        # Character n-grams for robustness
-        char_ngrams = []
-        for i in range(len(text) - 2):
-            char_ngrams.append(text[i:i+3].lower())
-        
-        # Create sparse vector
-        vector = [0.0] * self.embed_dim
-        
-        # Hash tokens into vector dimensions
-        for token in tokens:
-            idx = hash(token) % self.embed_dim
-            vector[idx] += 1.0
-        
-        # Hash character n-grams
-        for ngram in char_ngrams:
-            idx = hash(ngram) % self.embed_dim
-            vector[idx] += 0.5
-        
-        # Normalize
-        magnitude = math.sqrt(sum(x * x for x in vector))
-        if magnitude > 0:
-            vector = [x / magnitude for x in vector]
-        
-        return vector
-    
-    def cosine_similarity(self, vec_a: List[float], vec_b: List[float]) -> float:
-        """
-        Calculate cosine similarity between two vectors.
-        
-        Returns:
-            Similarity score in [0, 1] (higher = more similar)
-        """
-        if len(vec_a) != len(vec_b):
-            raise ValueError(f"Vector dimension mismatch: {len(vec_a)} vs {len(vec_b)}")
-        
-        # Dot product
-        dot_product = sum(a * b for a, b in zip(vec_a, vec_b))
-        
-        # Magnitudes
-        mag_a = math.sqrt(sum(a * a for a in vec_a))
-        mag_b = math.sqrt(sum(b * b for b in vec_b))
-        
-        if mag_a == 0 or mag_b == 0:
-            return 0.0
-        
-        similarity = dot_product / (mag_a * mag_b)
-        
-        # Clamp to [0, 1]
-        return max(0.0, min(1.0, similarity))
-    
-    def get_cached_embedding(self, text: str) -> List[float]:
-        """
-        Get embedding from cache if available, otherwise generate.
-        Same as embed_text() but explicit about caching.
-        """
-        return self.embed_text(text)
-    
-    def clear_cache(self):
-        """Clear embedding cache."""
-        self.cache = {}
-        if os.path.exists(self.cache_path):
-            os.remove(self.cache_path)
-        print("[EMBEDDER]: Cache cleared")
-
-
-if __name__ == "__main__":
-    print("="*60)
-    print("SEMANTIC EMBEDDER - Test Suite")
-    print("="*60 + "\n")
-    
-    embedder = SemanticEmbedder()
-    
-    # Test 1: Basic embedding
-    print("Test 1: Basic Embedding")
-    text = "React hooks allow functional components to use state"
-    embedding = embedder.embed_text(text)
-    print(f"  Text: '{text}'")
-    print(f"  Embedding dim: {len(embedding)}")
-    print(f"  First 5 values: {embedding[:5]}")
-    
-    # Test 2: Similarity between related concepts
-    print("\nTest 2: Semantic Similarity")
-    concepts = [
-        "React hooks and useEffect",
-        "Functional components with state management",
-        "Database connection pooling",
-        "Singleton design pattern"
-    ]
-    
-    embeddings = [embedder.embed_text(c) for c in concepts]
-    
-    print("\nSimilarity Matrix:")
-    for i, concept_i in enumerate(concepts):
-        for j, concept_j in enumerate(concepts):
-            if j >= i:  # Only upper triangle
-                sim = embedder.cosine_similarity(embeddings[i], embeddings[j])
-                print(f"  [{i}] ↔ [{j}]: {sim:.3f}")
-    
-    print("\nConcept Labels:")
-    for i, c in enumerate(concepts):
-        print(f"  [{i}]: {c}")
-    
-    # Test 3: Cache performance
-    print("\nTest 3: Cache Performance")
-    import time
-    
-    test_text = "This is a test string for cache performance"
-    
-    # First call (no cache)
-    start = time.time()
-    _ = embedder.embed_text(test_text)
-    first_time = time.time() - start
-    
-    # Second call (cached)
-    start = time.time()
-    _ = embedder.embed_text(test_text)
-    second_time = time.time() - start
-    
-    print(f"  First call: {first_time*1000:.2f}ms")
-    print(f"  Cached call: {second_time*1000:.2f}ms")
-    if second_time > 0:
-        print(f"  Speedup: {first_time/second_time:.1f}x")
-    else:
-        print(f"  Speedup: >100x (instant cache)")
-    
-    # Save cache
-    embedder.save_cache()
-    print(f"\n✅ Embedder operational")
-    print(f"   Mode: {embedder.mode}")
-    print(f"   Dimension: {embedder.embed_dim}")
-    print(f"   Cached embeddings: {len(embedder.cache)}")