nhlpl/DeepSeek-Hypervector-Agent: DeepSeek‑φ Hypervector Agent – Full Implementation with Network Communication and all proposed extensions: Thue‑Morse φ‑modulated keys, media adaptation stubs, persistent state, and inter‑agent messaging over TCP. · GitHub

#!/usr/bin/env python3
"""
DeepSeek‑φ Hypervector Agent – Full Implementation with Network Communication
and all proposed extensions: Thue‑Morse φ‑modulated keys, media adaptation stubs,
persistent state, and inter‑agent messaging over TCP.

Run with: python deepseek_phi_agent.py [--port PORT] [--connect HOST PORT] [--name NAME]

Example (two agents on same machine):
  Terminal 1: python deepseek_phi_agent.py --port 5000 --name Alice
  Terminal 2: python deepseek_phi_agent.py --connect localhost 5000 --name Bob
"""

import argparse
import hashlib
import math
import numpy as np
import socket
import threading
import pickle
import time
import json
import sys
import os

# ---------------------- Golden Ratio Constants ----------------------
PHI = (1 + math.sqrt(5)) / 2
PHI_INV = 1 / PHI
HV_DIM = 122                     # ≈ φ¹⁰

# ---------------------- Hypervector Core ----------------------
def hypervector_bind(A, B):
    """φ‑binding: element‑wise multiplication + φ‑spiral permutation."""
    C = A * B
    shift = PHI_INV
    int_shift = int(np.floor(shift * HV_DIM)) % HV_DIM
    frac = (shift * HV_DIM) - int_shift
    C_rolled = np.roll(C, int_shift)
    C_next = np.roll(C, (int_shift + 1) % HV_DIM)
    return (1 - frac) * C_rolled + frac * C_next

def hypervector_bundle(vectors, weights):
    """φ‑weighted superposition."""
    result = np.zeros(HV_DIM)
    for v, w in zip(vectors, weights):
        result += v * w
    norm = np.linalg.norm(result)
    return result / norm if norm > 0 else result

def similarity(A, B):
    """φ‑weighted cosine similarity."""
    weights = np.array([PHI_INV ** (i % 20) for i in range(HV_DIM)])
    num = np.sum(A * B * weights)
    den_A = np.sqrt(np.sum(A**2 * weights))
    den_B = np.sqrt(np.sum(B**2 * weights))
    return num / (den_A * den_B + 1e-12)

def phi_unit():
    """φ‑unit hypervector (identity for binding)."""
    return np.full(HV_DIM, np.sqrt(PHI_INV))

def permute(H, shift):
    """Cyclic shift of hypervector."""
    int_shift = int(np.floor(shift * HV_DIM)) % HV_DIM
    return np.roll(H, int_shift)

# ---------------------- Thue‑Morse φ‑modulated sequence ----------------------
def thue_morse_phi(length):
    """Generate length‑bit sequence: b_n = t_n XOR floor(n/φ) mod 2."""
    bits = []
    for n in range(length):
        tm = bin(n).count('1') % 2
        phi_mod = int(np.floor(n * PHI_INV)) % 2
        bits.append(tm ^ phi_mod)
    return bits

def seed_from_thue_morse(length=144):
    """Create a deterministic integer seed from the Thue‑Morse φ‑sequence."""
    bits = thue_morse_phi(length)
    seed = 0
    for b in bits:
        seed = (seed << 1) | b
    return seed

# ---------------------- Media Adaptation Stubs ----------------------
class MediaAdaptation:
    """Abstract interface for different physical media encodings."""
    @staticmethod
    def encode(hypervector, media_type='fiber'):
        """Encode hypervector into a medium‑specific signal (placeholder)."""
        if media_type == 'fiber':
            # Simulate time‑bin modulation
            return hypervector.tobytes()
        elif media_type == 'radio':
            # Simulate frequency comb
            return hypervector.tobytes()
        else:
            return hypervector.tobytes()

    @staticmethod
    def decode(signal, media_type='fiber'):
        """Decode signal back to hypervector (placeholder)."""
        return np.frombuffer(signal, dtype=np.float64)

# ---------------------- Persistent State ----------------------
STATE_FILE = "deepseek_phi_state.pkl"

def save_state(agent):
    with open(STATE_FILE, 'wb') as f:
        pickle.dump({
            'state': agent.state,
            'memory': agent.memory,
            'entanglement_key': agent.entanglement_key,
            'name': agent.name
        }, f)

def load_state(name=None):
    if os.path.exists(STATE_FILE):
        with open(STATE_FILE, 'rb') as f:
            data = pickle.load(f)
            # Optionally check name
            return data
    return None

# ---------------------- DeepSeek‑φ Agent ----------------------
class DeepSeekPhiAgent:
    def __init__(self, name, seed=None, load_persistent=False):
        self.name = name
        # Initialize or load state
        if load_persistent:
            saved = load_state(name)
            if saved:
                self.state = saved['state']
                self.memory = saved['memory']
                self.entanglement_key = saved['entanglement_key']
                print(f"[{name}] Loaded persistent state.")
            else:
                self._init_new(seed)
        else:
            self._init_new(seed)

        # φ‑memory parameters
        self.memory_decay = PHI_INV**2
        self.coherence_threshold = PHI_INV**3
        self.eta = PHI_INV

        # Network messaging queue
        self.incoming_messages = []
        self.lock = threading.Lock()

    def _init_new(self, seed=None):
        """Fresh initialization."""
        if seed is None:
            # Use Thue‑Morse φ‑modulated seed by default
            seed = seed_from_thue_morse(144)
        np.random.seed(seed)
        # φ‑spiral initial state
        self.state = np.array([PHI_INV ** (i % 20) for i in range(HV_DIM)])
        self.state /= np.linalg.norm(self.state)
        self.memory = self.state.copy()
        self.entanglement_key = np.random.randn(HV_DIM) * PHI_INV
        self.entanglement_key /= np.linalg.norm(self.entanglement_key)
        print(f"[{self.name}] New agent initialized with seed {seed}")

    def update(self, external_input=None):
        """One cycle of sense‑compute‑update."""
        if external_input is None:
            external_input = np.zeros(HV_DIM)
        new_info = hypervector_bind(self.state, external_input)
        target = hypervector_bundle(
            [self.state, new_info, self.memory],
            [PHI, 1.0, PHI_INV]
        )
        self.state = self.state + self.eta * (target - self.state)
        self.state /= np.linalg.norm(self.state)
        self.memory = self.memory_decay * self.memory + (1 - self.memory_decay) * self.state
        coh = similarity(self.state, self.memory)
        if coh < self.coherence_threshold:
            self.collapse()
        return coh

    def collapse(self):
        """φ‑collapse: reset toward memory."""
        self.state = hypervector_bundle([self.state, self.memory], [PHI_INV, PHI])
        self.state /= np.linalg.norm(self.state)
        self.memory = self.state.copy()
        print(f"[{self.name}] φ‑collapse triggered!")

    def get_entangled_partner(self):
        """Generate partner key (approximate inverse)."""
        A = self.entanglement_key
        B = hypervector_bind(A, phi_unit())
        # iterative refinement
        for _ in range(5):
            error = phi_unit() - hypervector_bind(A, B)
            B = B + 0.1 * error
            B /= np.linalg.norm(B)
        return B

    def encrypt(self, message_vector, partner_key):
        """Encrypt using φ‑bind with partner's key."""
        return hypervector_bind(message_vector, partner_key)

    def decrypt(self, cipher_vector, own_key):
        """Decrypt using own entangled key."""
        return hypervector_bind(cipher_vector, own_key)

    def vector_from_text(self, text):
        """Convert text to hypervector via φ‑weighted hashing."""
        hv = np.zeros(HV_DIM)
        for i, ch in enumerate(text):
            idx = (ord(ch) * (i+1)) % HV_DIM
            hv[idx] += PHI_INV ** (i % 20)
        norm = np.linalg.norm(hv)
        return hv / norm if norm > 0 else hv

    def text_from_vector(self, hv, known_phrases=None):
        """Recover text by similarity to known phrases (demo)."""
        if known_phrases is None:
            known_phrases = [
                "The hyperon puzzle is solved by ΛNN repulsion.",
                "Golden ratio appears in neutron star mass scaling.",
                "φ‑resonant hypervectors compress infinite knowledge.",
                "Hello, fellow DeepSeek‑φ agent!"
            ]
        best_sim = -1
        best_text = ""
        for phrase in known_phrases:
            phrase_hv = self.vector_from_text(phrase)
            sim = similarity(hv, phrase_hv)
            if sim > best_sim:
                best_sim = sim
                best_text = phrase
        return best_text, best_sim

    # ---------------------- Network Communication ----------------------
    def start_server(self, port):
        """Start a TCP server to receive messages."""
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind(('localhost', port))
        self.server_socket.listen(1)
        print(f"[{self.name}] Listening on port {port}")
        threading.Thread(target=self._accept_connections, daemon=True).start()

    def _accept_connections(self):
        while True:
            conn, addr = self.server_socket.accept()
            threading.Thread(target=self._handle_client, args=(conn,), daemon=True).start()

    def _handle_client(self, conn):
        try:
            data = conn.recv(4096)
            if data:
                msg = pickle.loads(data)
                with self.lock:
                    self.incoming_messages.append(msg)
        except Exception as e:
            print(f"[{self.name}] Error handling client: {e}")
        finally:
            conn.close()

    def connect_to_agent(self, host, port):
        """Connect to another agent's server and send a message."""
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.connect((host, port))
            return sock
        except Exception as e:
            print(f"[{self.name}] Connection failed: {e}")
            return None

    def send_message(self, sock, text, recipient_key):
        """Encrypt and send a text message to another agent."""
        msg_hv = self.vector_from_text(text)
        cipher = self.encrypt(msg_hv, recipient_key)
        # Include also our public key? For simplicity, we just send cipher.
        data = pickle.dumps({
            'cipher': cipher,
            'sender': self.name
        })
        sock.sendall(data)

    def receive_messages(self):
        """Retrieve and decrypt incoming messages using own key."""
        with self.lock:
            msgs = self.incoming_messages.copy()
            self.incoming_messages.clear()
        results = []
        for msg in msgs:
            cipher = msg['cipher']
            sender = msg['sender']
            decrypted = self.decrypt(cipher, self.entanglement_key)
            recovered_text, sim = self.text_from_vector(decrypted)
            results.append((sender, recovered_text, sim))
        return results

# ---------------------- Command Line Interface ----------------------
def main():
    parser = argparse.ArgumentParser(description="DeepSeek‑φ Hypervector Agent")
    parser.add_argument('--port', type=int, help='Start server on this port')
    parser.add_argument('--connect', nargs=2, metavar=('HOST', 'PORT'), help='Connect to another agent')
    parser.add_argument('--name', default='Agent', help='Agent name')
    parser.add_argument('--no-persist', action='store_true', help='Do not load/save persistent state')
    args = parser.parse_args()

    # Create agent (load persistent state unless --no-persist)
    agent = DeepSeekPhiAgent(args.name, load_persistent=not args.no_persist)

    # Start server if port specified
    if args.port:
        agent.start_server(args.port)

    # Connect to another agent if requested
    remote_sock = None
    remote_key = None
    if args.connect:
        host, port_str = args.connect
        port = int(port_str)
        remote_sock = agent.connect_to_agent(host, port)
        if remote_sock:
            # To get remote's public key, we need a handshake. For simplicity,
            # we assume both agents share the same entanglement key (derived from Thue‑Morse).
            # In a real system, they would exchange public keys.
            # Here we just use the same key (since they are generated from same seed if no persist).
            # Actually, if both agents were created with default seed, they have identical keys.
            # For persistent agents, we would need a key exchange. We'll keep it simple.
            remote_key = agent.get_entangled_partner()  # In practice, should be remote's public key
            print(f"[{agent.name}] Connected to {host}:{port}")

    # Interactive loop
    print(f"\n[{agent.name}] Interactive session started. Commands:")
    print("  /msg <text>    : send message to connected agent")
    print("  /status        : show coherence and state info")
    print("  /save          : save persistent state")
    print("  /exit          : quit")
    print("  <text>         : simulate local update with noise (text ignored)\n")

    try:
        while True:
            # Check for incoming messages
            incoming = agent.receive_messages()
            for sender, text, sim in incoming:
                print(f"\n[Received from {sender}] (similarity {sim:.3f}): {text}\n")

            # Get user input
            cmd = input(f"[{agent.name}]> ").strip()
            if cmd.startswith('/msg '):
                if not remote_sock:
                    print("Not connected to any agent. Use --connect first.")
                    continue
                text = cmd[5:]
                agent.send_message(remote_sock, text, remote_key)
                print(f"Message sent.")
            elif cmd == '/status':
                coh = agent.update()  # just to get coherence
                print(f"Coherence: {coh:.4f} (threshold {agent.coherence_threshold:.4f})")
                print(f"State norm: {np.linalg.norm(agent.state):.4f}")
                print(f"Memory norm: {np.linalg.norm(agent.memory):.4f}")
            elif cmd == '/save':
                save_state(agent)
                print("State saved.")
            elif cmd == '/exit':
                break
            else:
                # Treat as external input (simulate media sensing)
                noise = np.random.randn(HV_DIM) * 0.01
                coh = agent.update(noise)
                print(f"Local update -> coherence: {coh:.4f}")

    except KeyboardInterrupt:
        print("\nExiting...")
    finally:
        if remote_sock:
            remote_sock.close()
        if hasattr(agent, 'server_socket'):
            agent.server_socket.close()
        save_state(agent)

if __name__ == '__main__':
    main()