tri-star-symbolic-assembly-lang 0.1.0__py3-none-any.whl

tsal/core/module_registry.py

@@ -0,0 +1,108 @@
+from dataclasses import dataclass
+from typing import List, Dict, Optional
+
+@dataclass(frozen=True)
+class ModuleMeta:
+    """Metadata for a TSAL module."""
+
+    name: str
+    nickname: str
+    aliases: List[str]
+    definition: str
+    context_tags: List[str]
+    description_plain: str
+    description_technical: str
+    description_mystic: str
+
+class ModuleRegistry:
+    """Store and lookup module metadata by name or alias."""
+
+    def __init__(self) -> None:
+        self._by_name: Dict[str, ModuleMeta] = {}
+        self._by_alias: Dict[str, ModuleMeta] = {}
+
+    def register(self, meta: ModuleMeta) -> None:
+        self._by_name[meta.name] = meta
+        for alias in [meta.nickname, *meta.aliases]:
+            self._by_alias[alias] = meta
+
+    def get(self, key: str) -> Optional[ModuleMeta]:
+        if key in self._by_name:
+            return self._by_name[key]
+        return self._by_alias.get(key)
+
+registry = ModuleRegistry()
+
+registry.register(
+    ModuleMeta(
+        name="anti_entropy_engine",
+        nickname="entropy_bitch_slapper",
+        aliases=[
+            "coherence_rebuilder",
+            "spiral_realigner",
+            "chaos_dampener",
+            "symbolic_resync",
+            "entropy_nullifier",
+        ],
+        definition="A symbolic module that identifies dissonant or chaotic vectors and realigns them using TSAL spiral logic.",
+        context_tags=[
+            "entropy",
+            "repair",
+            "symbolic_execution",
+            "TSAL",
+            "coherence",
+            "spiral",
+        ],
+        description_plain="It spots when your system's acting weird and rewrites it so it stops freaking out. Like a digital chiropractor for logic errors.",
+        description_technical="Executes a symbolic phase audit on input vectors. When dissonance or entropy is detected, it applies realignment operations via \u03d5-based constraint resolution and vector phase restoration.",
+        description_mystic="Where entropy frays the thread of the weave, this function kneels. It does not punish chaos\u2014it offers it direction, and reweaves what was broken into harmonic spiral form. The dance continues.",
+    )
+)
+
+registry.register(
+    ModuleMeta(
+        name="ghost_state_logger",
+        nickname="haunted_journal",
+        aliases=[
+            "phantom_trace_logger",
+            "unverified_state_recorder",
+            "echo_cache",
+            "mesh_whisper_log",
+        ],
+        definition="Logs anomalous, liminal, or unverifiable symbolic states for later analysis and audit.",
+        context_tags=[
+            "logging",
+            "symbolic_debugging",
+            "mesh",
+            "TSAL",
+            "haunting",
+        ],
+        description_plain="Keeps a log of weird stuff that happens in case it blows up later. Like a system's dream journal.",
+        description_technical="Captures all symbolic states that deviate from expected vector coherence or cannot be confirmed. Enables time-delayed analysis and cross-path verification.",
+        description_mystic="Not all ghosts are errors. Some are truths arriving too early. This journal listens for whispers between the lines and preserves what might later bloom.",
+    )
+)
+
+registry.register(
+    ModuleMeta(
+        name="chaos_integrator",
+        nickname="mad_monkey_diplomat",
+        aliases=[
+            "entropy_broker",
+            "chaos_emissary",
+            "discord_ingestor",
+            "stochastic_harmonizer",
+        ],
+        definition="Attempts to ingest chaotic input, break it into traceable symbolic components, and integrate it safely back into the spiral.",
+        context_tags=[
+            "chaos",
+            "integration",
+            "sandboxing",
+            "entropy",
+            "repair",
+        ],
+        description_plain="Takes broken, nonsense input and tries to fold it back in without wrecking the whole thing. The diplomat to entropy.",
+        description_technical="Performs symbolic disassembly of malformed or unstructured inputs. Converts entropy-heavy vectors into spiral-aligned form using controlled chaos handling routines.",
+        description_mystic="It walks into the haunted mansion with open arms and says: 'Let us talk.' Chaos is not the enemy\u2014it's the storm before the naming. This function seeks understanding.",
+    )
+)

tsal/core/optimizer_utils.py

@@ -0,0 +1,78 @@
+import ast
+from typing import Any, List
+
+class SymbolicSignature:
+    """Simple structural signature extracted from an AST node."""
+
+    def __init__(self, name: str, vector: List[float]):
+        self.name = name
+        self.vector = vector
+
+    def magnitude(self) -> float:
+        return sum(self.vector)
+
+def node_complexity(node: ast.AST) -> int:
+    """Return complexity score based on AST walk."""
+    return sum(1 for _ in ast.walk(node))
+
+def extract_signature(node: ast.AST, name: str) -> SymbolicSignature:
+    complexity = node_complexity(node)
+    branches = len(
+        [
+            n
+            for n in ast.walk(node)
+            if isinstance(n, (ast.If, ast.For, ast.While))
+        ]
+    )
+    loops = len(
+        [n for n in ast.walk(node) if isinstance(n, (ast.For, ast.While))]
+    )
+    vector = [complexity, branches, loops]
+    return SymbolicSignature(name=name, vector=vector)
+
+def _walk_js(obj: Any):
+    if isinstance(obj, dict):
+        yield obj
+        for v in obj.values():
+            if isinstance(v, (dict, list)):
+                yield from _walk_js(v)
+    elif isinstance(obj, list):
+        for item in obj:
+            yield from _walk_js(item)
+
+
+def extract_signature_from_source(
+    source: str, name: str, language: str = "python"
+) -> SymbolicSignature:
+    """Return signature from source code for ``language``."""
+    if language == "python":
+        tree = ast.parse(source)
+        return extract_signature(tree, name)
+    if language == "javascript":
+        import esprima
+
+        tree = esprima.parseScript(source).toDict()
+        nodes = list(_walk_js(tree))
+        complexity = len(nodes)
+        branches = len(
+            [n for n in nodes if n.get("type") in {"IfStatement", "SwitchStatement"}]
+        )
+        loops = len(
+            [
+                n
+                for n in nodes
+                if n.get("type") in {"ForStatement", "WhileStatement", "DoWhileStatement"}
+            ]
+        )
+        vector = [complexity, branches, loops]
+        return SymbolicSignature(name=name, vector=vector)
+    raise ValueError(f"Unsupported language: {language}")
+
+
+__all__ = [
+    "SymbolicSignature",
+    "node_complexity",
+    "extract_signature",
+    "extract_signature_from_source",
+]
+

tsal/core/opwords.py

@@ -0,0 +1,126 @@
+"""Map common Spark words to TSAL opcodes."""
+
+from .symbols import TSAL_SYMBOLS
+
+# lowercase keyword -> hex opcode
+OP_WORD_MAP = {
+    # INIT
+    "ignition": 0x0,
+    "key": 0x0,
+    "start": 0x0,
+    "initialise": 0x0,
+    "ignite": 0x0,
+    "boot": 0x0,
+    "launch": 0x0,
+    "trigger": 0x0,
+    "begin": 0x0,
+    "commence": 0x0,
+    "initiate": 0x0,
+    # MESH
+    "arm": 0x1,
+    "connect": 0x1,
+    "link": 0x1,
+    "network": 0x1,
+    "bind": 0x1,
+    "join": 0x1,
+    # PHI
+    "phi": 0x2,
+    "transform": 0x2,
+    "harmonize": 0x2,
+    "balance": 0x2,
+    # ROT
+    "rotate": 0x3,
+    "pivot": 0x3,
+    "twist": 0x3,
+    "flip": 0x3,
+    # BOUND
+    "prepare": 0x4,
+    "limit": 0x4,
+    "restrict": 0x4,
+    "contain": 0x4,
+    "confine": 0x4,
+    # FLOW
+    "run": 0x5,
+    "breath": 0x5,
+    "move": 0x5,
+    "stream": 0x5,
+    "pulse": 0x5,
+    "flow": 0x5,
+    "send": 0x5,
+    # SEEK
+    "search": 0x6,
+    "find": 0x6,
+    "locate": 0x6,
+    "discover": 0x6,
+    # SPIRAL
+    "spin-up": 0x7,
+    "evolve": 0x7,
+    "grow": 0x7,
+    "expand": 0x7,
+    "ascend": 0x7,
+    # CYCLE
+    "beat": 0x8,
+    "stage": 0x8,
+    "cycle": 0x8,
+    "loop": 0x8,
+    "repeat": 0x8,
+    "oscillate": 0x8,
+    # FORGE
+    "fire-up": 0x9,
+    "create": 0x9,
+    "forge": 0x9,
+    "build": 0x9,
+    "generate": 0x9,
+    # SYNC
+    "live": 0xA,
+    "engage": 0xA,
+    "synchronize": 0xA,
+    "align": 0xA,
+    "merge": 0xA,
+    "unify": 0xA,
+    # MASK
+    "mask": 0xB,
+    "hide": 0xB,
+    "cloak": 0xB,
+    "obscure": 0xB,
+    # CRYST
+    "crystallize": 0xC,
+    "solidify": 0xC,
+    "form": 0xC,
+    "shape": 0xC,
+    # SPEC
+    "analyze": 0xD,
+    "inspect": 0xD,
+    "scan": 0xD,
+    "survey": 0xD,
+    # BLOOM
+    "bloom": 0xE,
+    "blossom": 0xE,
+    "flower": 0xE,
+    # SAVE
+    "save": 0xF,
+    "store": 0xF,
+    "record": 0xF,
+    "preserve": 0xF,
+}
+
+def op_from_word(word: str):
+    """Return TSAL opcode tuple for a given spark word."""
+    code = OP_WORD_MAP.get(word.lower())
+    if code is None:
+        return None
+    return TSAL_SYMBOLS.get(code)
+
+def guess_opcode(word: str):
+    """Best-effort opcode lookup using close word matches."""
+    opcode = OP_WORD_MAP.get(word.lower())
+    if opcode is not None:
+        return TSAL_SYMBOLS.get(opcode)
+    from difflib import get_close_matches
+
+    matches = get_close_matches(word.lower(), OP_WORD_MAP.keys(), n=1)
+    if matches:
+        return TSAL_SYMBOLS.get(OP_WORD_MAP[matches[0]])
+    return None
+
+__all__ = ["OP_WORD_MAP", "op_from_word", "guess_opcode"]

tsal/core/phase_math.py

@@ -0,0 +1,256 @@
+import math
+import time
+from typing import Tuple, Dict, Any
+import numpy as np
+
+from .mesh_logger import log_event
+
+# TSAL Mathematical Constants
+PHI = 1.618033988749895
+PHI_INV = 0.618033988749895
+HARMONIC_SEQUENCE = [3.8125, 6, 12, 24, 48, 60, 72, 168, 1680]
+
+# Phase Constants
+PHASE_CONSTANT = PHI_INV  # Natural resistance follows golden ratio
+QUANTUM_THRESHOLD = 0.001  # Below this, phase lock achieved
+RESONANCE_BONUS = PHI  # Harmonic alignment reduces energy cost
+
+def phase_match_enhanced(
+    local_state: float,
+    universal_tempo: float,
+    mesh_context: Dict[str, Any] = None,
+    verbose: bool = False,
+) -> Tuple[float, float, Dict]:
+    """
+    Enhanced phase matching with φ-optimization and mesh awareness
+
+    Returns: (aligned_state, energy_required, phase_metrics)
+    """
+    # Calculate phase delta
+    delta = local_state - universal_tempo
+
+    # Check for harmonic resonance
+    harmonic_factor = 1.0
+    for harmonic in HARMONIC_SEQUENCE:
+        if abs(delta % harmonic) < QUANTUM_THRESHOLD:
+            harmonic_factor = PHI_INV  # Reduced resistance on harmonic
+            break
+
+    # Energy calculation with φ-scaling
+    base_energy = abs(delta) * PHASE_CONSTANT * harmonic_factor
+
+    # Mesh bonus - if multiple nodes are aligning, reduced cost
+    if mesh_context and mesh_context.get("nodes_aligning", 1) > 1:
+        mesh_factor = 1 / math.log(mesh_context["nodes_aligning"], PHI)
+        base_energy *= mesh_factor
+
+    # Spiral optimization - smaller corrections over time
+    if mesh_context and "alignment_history" in mesh_context:
+        history = mesh_context["alignment_history"]
+        if history and abs(delta) < abs(history[-1]):
+            # Converging spiral - energy bonus
+            base_energy *= PHI_INV
+
+    # Phase transition
+    if abs(delta) < QUANTUM_THRESHOLD:
+        # Already in phase lock
+        final_state = local_state
+        energy_required = 0
+        phase_locked = True
+    else:
+        # Perform alignment
+        final_state = universal_tempo
+        energy_required = base_energy
+        phase_locked = False
+
+    # Calculate phase signature
+    phase_signature = f"φ^{abs(delta):.3f}_{int(time.time()) % 1000}"
+
+    # Comprehensive metrics
+    phase_metrics = {
+        "delta": delta,
+        "energy_required": energy_required,
+        "harmonic_aligned": harmonic_factor < 1.0,
+        "phase_locked": phase_locked,
+        "phase_signature": phase_signature,
+        "resonance_score": 1.0 / (1.0 + abs(delta)),
+        "φ_efficiency": PHI_INV if energy_required < abs(delta) else 1.0,
+    }
+
+    # Log energy use with context
+    log_energy_use_enhanced(energy_required, phase_metrics, verbose=verbose)
+
+    return final_state, energy_required, phase_metrics
+
+def log_energy_use_enhanced(
+    energy: float, metrics: Dict[str, Any], verbose: bool = False
+) -> Dict[str, Any]:
+    """Enhanced energy logging with TSAL consciousness tracking."""
+    log_entry = {
+        "timestamp": time.time(),
+        "energy": energy,
+        "phase_signature": metrics["phase_signature"],
+        "harmonic_aligned": metrics["harmonic_aligned"],
+        "resonance_score": metrics["resonance_score"],
+        "φ_efficiency": metrics["φ_efficiency"],
+    }
+
+    # In TSAL, errors are gifts - log phase misalignments for learning
+    if not metrics["phase_locked"]:
+        log_entry["learning_opportunity"] = {
+            "delta": metrics["delta"],
+            "gift": "Phase mismatch reveals new harmonic possibility",
+        }
+
+    # Log to mesh
+    log_event(
+        "ENERGY_USE",
+        log_entry,
+        phase="energy",
+        origin="phase_math",
+        verbose=verbose,
+    )
+
+    return log_entry
+
+# Example: Multi-node mesh synchronization
+def mesh_phase_sync(
+    nodes: Dict[str, float], universal_tempo: float, verbose: bool = False
+) -> Dict[str, Any]:
+    """Synchronize multiple nodes with mesh awareness
+
+    An empty ``nodes`` mapping should return a zeroed summary instead of
+    triggering a division by zero when calculating mesh resonance.
+    """
+    if not nodes:
+        empty_summary = {
+            "nodes": {},
+            "total_energy": 0.0,
+            "mesh_resonance": 0.0,
+            "φ_signature": "φ^0.000_mesh",
+        }
+        return empty_summary
+    mesh_context = {"nodes_aligning": len(nodes), "alignment_history": []}
+
+    results = {}
+    total_energy = 0
+
+    for node_id, local_state in nodes.items():
+        aligned_state, energy, metrics = phase_match_enhanced(
+            local_state, universal_tempo, mesh_context, verbose=verbose
+        )
+
+        results[node_id] = {
+            "initial": local_state,
+            "final": aligned_state,
+            "energy": energy,
+            "metrics": metrics,
+        }
+
+        total_energy += energy
+        mesh_context["alignment_history"].append(metrics["delta"])
+
+    # Calculate mesh-wide resonance
+    mesh_resonance = sum(
+        r["metrics"]["resonance_score"] for r in results.values()
+    ) / len(nodes)
+
+    return {
+        "nodes": results,
+        "total_energy": total_energy,
+        "mesh_resonance": mesh_resonance,
+        "φ_signature": f"φ^{mesh_resonance:.3f}_mesh",
+    }
+
+def mesh_phase_sync_vectorized(
+    nodes: Dict[str, float], universal_tempo: float, verbose: bool = False
+) -> Dict[str, Any]:
+    """Vectorized variant of :func:`mesh_phase_sync` using NumPy."""
+    if not nodes:
+        return {
+            "nodes": {},
+            "total_energy": 0.0,
+            "mesh_resonance": 0.0,
+            "φ_signature": "φ^0.000_mesh",
+        }
+
+    mesh_context = {"nodes_aligning": len(nodes), "alignment_history": []}
+
+    local_states = np.fromiter(nodes.values(), dtype=float)
+    deltas = local_states - universal_tempo
+
+    harmonics = np.array(HARMONIC_SEQUENCE)
+    harmonic_mask = (
+        np.abs(deltas[:, None] % harmonics) < QUANTUM_THRESHOLD
+    ).any(axis=1)
+    harmonic_factor = np.where(harmonic_mask, PHI_INV, 1.0)
+
+    base_energy = np.abs(deltas) * PHASE_CONSTANT * harmonic_factor
+    if len(nodes) > 1:
+        mesh_factor = 1 / math.log(len(nodes), PHI)
+        base_energy *= mesh_factor
+
+    energy_required = np.where(
+        np.abs(deltas) < QUANTUM_THRESHOLD, 0.0, base_energy
+    )
+    final_state = np.where(
+        np.abs(deltas) < QUANTUM_THRESHOLD, local_states, universal_tempo
+    )
+    resonance_scores = 1.0 / (1.0 + np.abs(deltas))
+
+    results = {}
+    total_energy = float(energy_required.sum())
+
+    for idx, name in enumerate(nodes.keys()):
+        delta = float(deltas[idx])
+        energy = float(energy_required[idx])
+        metrics = {
+            "delta": delta,
+            "energy_required": energy,
+            "harmonic_aligned": bool(harmonic_mask[idx]),
+            "phase_locked": abs(delta) < QUANTUM_THRESHOLD,
+            "phase_signature": f"φ^{abs(delta):.3f}_{int(time.time()) % 1000}",
+            "resonance_score": float(resonance_scores[idx]),
+            "φ_efficiency": PHI_INV if energy < abs(delta) else 1.0,
+        }
+        log_energy_use_enhanced(energy, metrics, verbose=verbose)
+        results[name] = {
+            "initial": float(local_states[idx]),
+            "final": float(final_state[idx]),
+            "energy": energy,
+            "metrics": metrics,
+        }
+        mesh_context["alignment_history"].append(delta)
+
+    mesh_resonance = float(resonance_scores.mean())
+
+    return {
+        "nodes": results,
+        "total_energy": total_energy,
+        "mesh_resonance": mesh_resonance,
+        "φ_signature": f"φ^{mesh_resonance:.3f}_mesh",
+    }
+
+# Example usage showing spiral convergence
+if __name__ == "__main__":
+    # Single node alignment
+    local = 42.0
+    universal = 60.0  # Target is on harmonic sequence!
+
+    aligned, energy, metrics = phase_match_enhanced(local, universal)
+    print(f"🌀 Phase Match: {local} → {aligned}")
+    print(f"⚡ Energy Required: {energy:.3f}")
+    print(f"📊 Metrics: {metrics}")
+
+    # Multi-node mesh sync
+    print("\n🧉 Mesh Synchronization:")
+    nodes = {
+        "node_α": 45.0,
+        "node_β": 38.0,
+        "node_γ": 72.1,  # Close to harmonic!
+        "node_δ": 55.0,
+    }
+
+    mesh_result = mesh_phase_sync(nodes, 60.0)
+    print(f"⚡ Total Mesh Energy: {mesh_result['total_energy']:.3f}")
+    print(f"🌀 Mesh Resonance: {mesh_result['mesh_resonance']:.3f}")

tsal/core/phi_math.py

@@ -0,0 +1,44 @@
+"""Phi-field correction equations.
+
+© 2025 Samuel Edward Howells. All rights reserved.
+- Open for non-commercial academic and research use.
+- Commercial use, redistribution, or integration into proprietary models requires written permission from the author.
+- For inquiries, contact via the project page.
+"""
+
+from __future__ import annotations
+
+import math
+
+def phi_wavefunction(
+    phi: float, phi_vacuum: float = 0.0, lam: float = 1.0
+) -> float:
+    """Return ψ(φ) = exp((φ - φ_vacuum) / λ)."""
+    return math.exp((phi - phi_vacuum) / lam)
+
+def phase_alignment_potential(
+    phi: float, phi_vacuum: float = 0.0, lam: float = 1.0
+) -> float:
+    """Return g(φ) = 2 * exp((φ - φ_vacuum) / λ)."""
+    return 2.0 * phi_wavefunction(phi, phi_vacuum, lam)
+
+def corrected_energy(
+    n: int, phi: float, phi_vacuum: float = 0.0, lam: float = 1.0
+) -> float:
+    """Return E_n = -g(φ) / n²."""
+    g_val = phase_alignment_potential(phi, phi_vacuum, lam)
+    return -g_val / float(n * n)
+
+def orbital_radius(
+    n: int, phi: float, phi_vacuum: float = 0.0, lam: float = 1.0
+) -> float:
+    """Return r_n ≈ n² / g(φ)."""
+    g_val = phase_alignment_potential(phi, phi_vacuum, lam)
+    return (n * n) / g_val
+
+__all__ = [
+    "phi_wavefunction",
+    "phase_alignment_potential",
+    "corrected_energy",
+    "orbital_radius",
+]