Protocol 45: Hex Dissolution & Suite Restoration

logos/ingest/dissolution.py

@@ -0,0 +1,102 @@
+import os
+import binascii
+import numpy as np
+import sympy
+from collections import Counter
+
+class DissolutionCore:
+    def __init__(self, chunk_size=1024):
+        """
+        The 'Stomach' of LOGOS. Digests raw files into Mathematical Atoms.
+        chunk_size: How many bytes to process at once (The Bite Size).
+        Protocol 45: Hex Dissolution.
+        """
+        self.chunk_size = chunk_size
+        
+        # Pre-compute Prime Weights for all Byte values (0-255)
+        # This is a lookup table for "Semantic Gravity"
+        self.atom_weights = self._generate_atomic_weights()
+
+    def _generate_atomic_weights(self):
+        """
+        Maps every possible Byte (00-FF) to its Greatest Prime Factor (GPF).
+        Ex: 'FF' (255) -> Factors: 3, 5, 17 -> GPF: 17
+        Ex: '07' (7)   -> Factors: 7      -> GPF: 7
+        """
+        weights = {}
+        for i in range(256):
+            if i < 2:
+                weights[i] = 0 # Null/Unity has no heat
+            else:
+                factors = sympy.primefactors(i)
+                weights[i] = max(factors)
+        return weights
+
+    def ingest_file(self, file_path):
+        """
+        Reads a file and dissolves it into a Hex-Atom Stream.
+        Returns: A stream of 'Physical Atoms' ready for the Tension Web.
+        """
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Target not acquired: {file_path}")
+
+        print(f">> [DISSOLVE] Initiating breakdown of: {os.path.basename(file_path)}")
+        
+        hex_stream = []
+        heat_map = []
+        
+        with open(file_path, 'rb') as f:
+            while True:
+                # 1. Read Binary
+                chunk = f.read(self.chunk_size)
+                if not chunk:
+                    break
+                
+                # 2. Convert to Integers (The Atoms)
+                # We work with Ints (0-255) because they map directly to Primes
+                atoms = list(chunk) 
+                
+                # 3. Calculate 'Heat' (GPF) for this chunk
+                chunk_heat = [self.atom_weights[a] for a in atoms]
+                
+                # 4. Store (In production, this streams to the DB/Visualizer)
+                hex_stream.extend(atoms)
+                heat_map.extend(chunk_heat)
+
+        return self._analyze_residue(hex_stream, heat_map)
+
+    def _analyze_residue(self, atoms, heat):
+        """
+        Produces the 'Meta-Tensor' report from the dissolved matter.
+        """
+        total_atoms = len(atoms)
+        avg_heat = np.mean(heat) if heat else 0
+        entropy = self._calculate_shannon_entropy(atoms)
+        
+        # Find the 'Dominant Resonance' (Most frequent Prime Weight)
+        if heat:
+            heat_counts = Counter(heat)
+            dominant_prime = heat_counts.most_common(1)[0][0]
+        else:
+            dominant_prime = 0
+
+        return {
+            "status": "DISSOLVED",
+            "total_atoms": total_atoms,
+            "system_entropy": f"{entropy:.4f}",
+            "average_heat": f"{avg_heat:.2f}",
+            "dominant_resonance": f"Prime {dominant_prime}",
+            "hex_preview": binascii.hexlify(bytearray(atoms[:16])).decode('utf-8').upper()
+        }
+
+    def _calculate_shannon_entropy(self, data):
+        """
+        Standard entropy calculation to detect 'Noise' vs 'Signal'.
+        """
+        if not data: return 0
+        counts = Counter(data)
+        probs = [count / len(data) for count in counts.values()]
+        return -sum(p * np.log2(p) for p in probs)
+
+if __name__ == "__main__":
+    print("Dissolution Core v1.0")

logos/logos_suite.py

@@ -0,0 +1,75 @@
+import sys
+import os
+import time
+
+# Ensure logos in path
+# If running as script, parent dir needed
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.insert(0, parent_dir)
+
+def main_menu():
+    print("\n")
+    print("========================================")
+    print("   LOGOS STRATOS - MANIFOLD LAUNCHER    ")
+    print("========================================")
+    print("1. Start Neural Router (Server)")
+    print("2. Launch MTL REPL (Interactive)")
+    print("3. Ingest File (Hex Dissolution)")
+    print("4. Exit")
+    print("========================================")
+    
+    choice = input(">> Select Directive: ")
+    
+    if choice == '1':
+        print(">> Igniting Neural Router...")
+        # Use subprocess to run module
+        os.system(f"{sys.executable} -m logos.server")
+    elif choice == '2':
+        print(">> Accessing Manifold REPL...")
+        try:
+            from logos.mtl.interpreter import MTLInterpreter
+            interpreter = MTLInterpreter()
+            print("MTL v33.0 Ready. (Type 'exit' to quit)")
+            while True:
+                code = input("mtl> ")
+                if code.lower() in ['exit', 'quit']: break
+                try:
+                    res = interpreter.execute(code)
+                    print(f"=> {res}")
+                except Exception as ex:
+                    print(f"Error: {ex}")
+        except Exception as e:
+            print(f"REPL Error: {e}")
+            input("Press Enter...")
+    elif choice == '3':
+        print(">> [INGEST] Enter path to target file (Image/Video/Text):")
+        target_path = input("   >> Path: ").strip().strip('"')
+        try:
+            from logos.ingest.dissolution import DissolutionCore
+            core = DissolutionCore()
+            print(">> Engaging Dissolution Protocols...")
+            report = core.ingest_file(target_path)
+            print("\n" + "="*40)
+            print(f"  [STATUS]    {report['status']}")
+            print(f"  [ATOMS]     {report['total_atoms']}")
+            print(f"  [HEAT]      {report['average_heat']} (Avg GPF)")
+            print(f"  [RESONANCE] {report['dominant_resonance']}")
+            print(f"  [ENTROPY]   {report['system_entropy']}")
+            print(f"  [HEAD]      {report['hex_preview']}...")
+            print("="*40 + "\n")
+        except Exception as e:
+            print(f"[!] DISSOLUTION FAILED: {e}")
+        input("Press Enter to stabilize...")
+    elif choice == '4':
+        sys.exit(0)
+    else:
+        pass # loop
+
+if __name__ == "__main__":
+    while True:
+        try:
+            main_menu()
+        except KeyboardInterrupt:
+            sys.exit(0)

logos_project

@@ -1 +0,0 @@
-Subproject commit 75b641f8e63f4fc840b4dd5b63ec2e4113f163a7