diff --git a/python/quine.py b/python/quine.py new file mode 100644 index 00000000..97280e2e --- /dev/null +++ b/python/quine.py @@ -0,0 +1,738 @@ +""" +quine.py — SilverSight Self-Replication Engine +============================================== + +Turing-complete weird machine built on AVM + FAMM + DNA co-evolution. +Implements: Introspect, EncodeSelf, Replicate, Mutate, Heal, Boot. + +Gold standard: machine outputs binary that, when executed, produces +functionally identical machine with same self-description. + +Author: allaunthefox +License: MIT +""" + +from __future__ import annotations + +import hashlib +import json +import lzma +import struct +from dataclasses import dataclass, field +from typing import Dict, List, Optional, Tuple + +# ── DNA codec imports ────────────────────────────────────────────────────── +# We import from dna_codec.py the core encoding functions +try: + from dna_codec import ( + int_to_dna, + dna_to_int, + bytes_to_dna, + dna_to_bytes, + encode_with_metadata, + decode_with_metadata, + encode_all_solutions, + dna_to_greek, + greek_to_dna, + ) + from dna_lut import ( + build_lut, + find_optimal_lut, + lookup_encode, + lookup_decode, + ) +except ImportError: + # Fallback: implement minimal codec if imports fail + def int_to_dna(value: int, length: int) -> str: + """Minimal int→DNA using alphabet ABCGPSTZ.""" + ALPHABET = "ABCGPSTZ" + if value < 0: + raise ValueError("value must be non-negative") + result = "" + for _ in range(length): + result = ALPHABET[value % 8] + result + value //= 8 + if value > 0: + raise ValueError(f"value too large for {length} digits") + return result + + def dna_to_int(dna: str) -> int: + ALPHABET = "ABCGPSTZ" + result = 0 + for c in dna: + result = result * 8 + ALPHABET.index(c) + return result + + def bytes_to_dna(data: bytes) -> str: + """Encode bytes as DNA by chunking (3 bytes → 8 bases).""" + ALPHABET = "ABCGPSTZ" + chunks = [] + for i in range(0, len(data), 3): + chunk = data[i:i+3] + # Pad to exactly 3 bytes for consistent encoding + chunk = chunk.ljust(3, b'\x00') + val = int.from_bytes(chunk, "big") + dna_chunk = "" + for _ in range(8): + dna_chunk = ALPHABET[val % 8] + dna_chunk + val //= 8 + chunks.append(dna_chunk) + return "".join(chunks) + + def dna_to_bytes(dna: str) -> bytes: + """Decode DNA to bytes by chunking (8 bases → 3 bytes).""" + ALPHABET = "ABCGPSTZ" + chunks = [] + for i in range(0, len(dna), 8): + chunk = dna[i:i+8] + val = 0 + for c in chunk: + val = val * 8 + ALPHABET.index(c) + chunks.append(val.to_bytes(3, "big")) + return b"".join(chunks) + + def encode_with_metadata(data: bytes, lut, prefix: str = "A") -> dict: + dna = bytes_to_dna(data) + return {"dna": prefix + dna, "encoding_info": "minimal"} + + def decode_with_metadata(record: dict, lut) -> bytes: + dna = record["dna"] + if dna[0] == "A": + dna = dna[1:] + return dna_to_bytes(dna) + + def encode_all_solutions(solutions, **kwargs): + return [{"x": s, "dna": int_to_dna(hash(s) % (8**10), 10), + "energy": kwargs.get("energies", [0])[0]} for s in solutions] + + def dna_to_greek(dna: str) -> str: + mapping = {"A": "Φ", "T": "Λ", "G": "Ρ", "C": "Κ", + "B": "Ω", "S": "Σ", "P": "Π", "Z": "Ζ"} + return "".join(mapping.get(c, c) for c in dna) + + def greek_to_dna(greek: str) -> str: + mapping = {"Φ": "A", "Λ": "T", "Ρ": "G", "Κ": "C", + "Ω": "B", "Σ": "S", "Π": "P", "Ζ": "Z"} + return "".join(mapping.get(c, c) for c in greek) + + +# ── Q16.16 fixed-point ──────────────────────────────────────────────────── +Q16 = 16 +Q_ONE = 1 << Q16 # 65536 + + +def to_q16_16(value: float) -> int: + """Convert float to Q16.16 fixed-point.""" + return int(round(value * Q_ONE)) + + +def from_q16_16(value: int) -> float: + """Convert Q16.16 fixed-point to float.""" + return value / Q_ONE + + +# ── FAMM Cell (delay-line memory) ───────────────────────────────────────── +@dataclass +class FAMMCell: + """Single FAMM delay-line cell.""" + data: int = 0 # Q16.16 stored value + delay: int = 0 # Q16.16 access delay + delay_mass: int = 0 # Q16.16 causal constraint mass + delay_weight: int = 0 # Q16.16 constraint strength + + def to_dict(self) -> dict: + return { + "data": self.data, + "delay": self.delay, + "delay_mass": self.delay_mass, + "delay_weight": self.delay_weight, + } + + @classmethod + def from_dict(cls, d: dict) -> FAMMCell: + return cls(d["data"], d["delay"], d["delay_mass"], d["delay_weight"]) + + +# ── Scar (violation memory) ─────────────────────────────────────────────── +@dataclass +class Scar: + """Persistent memory of a constraint violation.""" + pressure: int # Q16.16 pressure value + mode: str # violation mode (e.g., "SIDON_COLLISION", "GODEL_BOUNDARY") + timestamp: int = 0 # generation counter when scar was created + + def to_dict(self) -> dict: + return {"pressure": self.pressure, "mode": self.mode, + "timestamp": self.timestamp} + + @classmethod + def from_dict(cls, d: dict) -> Scar: + return cls(d["pressure"], d["mode"], d.get("timestamp", 0)) + + +# ── Machine State (everything that gets replicated) ─────────────────────── +@dataclass +class MachineState: + """Complete state of the weird machine — this IS what gets replicated.""" + + # AVM core + stack: List[str] = field(default_factory=list) + fuel: int = 1000 + instruction_pointer: int = 0 + history: List[str] = field(default_factory=list) + + # FAMM memory + famm_cells: List[FAMMCell] = field(default_factory=list) + + # Scars (persistent violation memory) + scars: List[Scar] = field(default_factory=list) + + # Generation counter + generation: int = 0 + + # Determinism seed + seed: int = 42 + + def to_dict(self) -> dict: + """Serialize to dictionary (JSON-compatible).""" + return { + "stack": self.stack, + "fuel": self.fuel, + "instruction_pointer": self.instruction_pointer, + "history": self.history[-100:], # cap history + "famm_cells": [c.to_dict() for c in self.famm_cells], + "scars": [s.to_dict() for s in self.scars], + "generation": self.generation, + "seed": self.seed, + } + + @classmethod + def from_dict(cls, d: dict) -> MachineState: + """Deserialize from dictionary.""" + return cls( + stack=d.get("stack", []), + fuel=d.get("fuel", 1000), + instruction_pointer=d.get("instruction_pointer", 0), + history=d.get("history", []), + famm_cells=[FAMMCell.from_dict(c) for c in d.get("famm_cells", [])], + scars=[Scar.from_dict(s) for s in d.get("scars", [])], + generation=d.get("generation", 0), + seed=d.get("seed", 42), + ) + + def total_famm_pressure(self) -> int: + """Total scar pressure (Ω in Baker-analogue notation).""" + return sum(s.pressure for s in self.scars) + + +# ── Receipt (SilverSight standard) ──────────────────────────────────────── +@dataclass +class Receipt: + """SilverSight Receipt — the interface between machine and verifier.""" + receipt_id: str = "" + expression: str = "" + final_state: str = "Ζ" + tic_count: int = 0 + fuel_used: int = 0 + path_cost: Optional[float] = None + library_refs: List[str] = field(default_factory=list) + verified: bool = False + generation: int = 0 + parent_id: str = "" + scar_hash: str = "" + identity_check: bool = False + + def to_dict(self) -> dict: + return { + "receiptID": self.receipt_id, + "expression": self.expression, + "finalState": self.final_state, + "ticCount": self.tic_count, + "fuelUsed": self.fuel_used, + "pathCost": self.path_cost, + "libraryRefs": self.library_refs, + "verified": self.verified, + "generation": self.generation, + "parentID": self.parent_id, + "scarHash": self.scar_hash, + "identityCheck": self.identity_check, + } + + +# ── INTROSPECT: Read self → DNA ─────────────────────────────────────────── +def introspect(state: MachineState) -> str: + """ + Read the current machine state and encode as DNA sequence. + + This is the self-description — the machine reading its own memory. + Deterministic: same state → same DNA (required for replication). + + Args: + state: current MachineState + + Returns: + DNA sequence representing the complete machine state + """ + # Step 1: Serialize to JSON + json_bytes = json.dumps(state.to_dict(), sort_keys=True).encode("utf-8") + + # Step 2: Compress + compressed = lzma.compress(json_bytes) + + # Step 3: Encode as DNA + dna = bytes_to_dna(compressed) + + # Step 4: Add header (version + length + checksum prefix) + version_dna = "A" # version 1 + length_bytes = len(compressed).to_bytes(4, "big") + length_dna = int_to_dna(int.from_bytes(length_bytes, "big"), 6) + # 8^11 = 8,589,934,592 > 2^32 = 4,294,967,296 + checksum_prefix = int_to_dna( + int(hashlib.sha256(compressed).hexdigest()[:8], 16), 11 + ) + + return version_dna + length_dna + checksum_prefix + dna + + +# ── ENCODESELF: DNA + bootstrap → binary ───────────────────────────────── +BOOTSTRAP_CODE = ''' +""" +SilverSight Weird Machine Bootstrap +This code reconstructs the machine from its DNA self-description. +""" +import lzma, json, hashlib, sys + +ALPHABET = "ABCGPSTZ" + +def dna_to_int(dna): + result = 0 + for c in dna: + result = result * 8 + ALPHABET.index(c) + return result + +def dna_to_bytes(dna): + value = dna_to_int(dna) + byte_len = (len(dna) + 1) // 2 + return value.to_bytes(byte_len, "big") + +def reconstruct(compressed_dna): + compressed = dna_to_bytes(compressed_dna) + json_bytes = lzma.decompress(compressed) + return json.loads(json_bytes.decode("utf-8")) + +if __name__ == "__main__": + # Read DNA from stdin or file + dna_input = sys.stdin.read().strip() + # Skip header (1 + 6 + 8 = 15 chars) + compressed_dna = dna_input[18:] + state_dict = reconstruct(compressed_dna) + print(json.dumps(state_dict, indent=2)) +'''.strip() + + +def encode_self(state: MachineState) -> bytes: + """ + Produce a binary quine: when executed, reconstructs the machine. + + Args: + state: current MachineState + + Returns: + bytes: Python script that reconstructs the machine from DNA + """ + # Step 1: Introspect (get DNA) + dna = introspect(state) + + # Step 2: Build quine + # The output script contains the DNA as a string literal + # When run, it decodes the DNA and reconstructs the state + quine_script = f'''#!/usr/bin/env python3 +{BOOTSTRAP_CODE} + +# Embedded DNA self-description (generation {state.generation}) +EMBEDDED_DNA = """{dna}""" + +if __name__ == "__main__": + # Use embedded DNA if no stdin input + dna_input = sys.stdin.read().strip() or EMBEDDED_DNA + compressed_dna = dna_input[18:] + state_dict = reconstruct(compressed_dna) + print(json.dumps(state_dict, indent=2)) + # TODO: actually reconstruct MachineState and resume execution +''' + + return quine_script.encode("utf-8") + + +# ── REPLICATE: DNA → reconstructed state ────────────────────────────────── +def replicate(dna: str) -> MachineState: + """ + Reconstruct machine state from DNA sequence. + + Args: + dna: DNA sequence from introspect() + + Returns: + MachineState: reconstructed state + """ + # Step 1: Parse header (1 + 6 + 11 = 18 chars) + if len(dna) < 18: + raise ValueError("DNA too short — invalid format") + + version = dna[0] # 'A' = version 1 + if version != "A": + raise ValueError(f"Unknown DNA version: {version}") + + length_dna = dna[1:7] + expected_length = dna_to_int(length_dna) + checksum_dna = dna[7:18] + compressed_dna = dna[18:] + + # Step 2: Decode compressed data (trim to header length) + compressed_padded = dna_to_bytes(compressed_dna) + compressed = compressed_padded[:expected_length] + + # Step 3: Verify checksum + checksum_int = dna_to_int(checksum_dna) + expected_checksum = int.to_bytes(checksum_int, 4, "big") + actual_checksum = hashlib.sha256(compressed).digest()[:4] + if expected_checksum != actual_checksum: + raise ValueError("Checksum mismatch — DNA corrupted or mutated") + + # Step 4: Decompress + json_bytes = lzma.decompress(compressed) + + # Step 5: Deserialize + state_dict = json.loads(json_bytes.decode("utf-8")) + state = MachineState.from_dict(state_dict) + + # Step 6: Increment generation + state.generation += 1 + + return state + + +# ── VERIFY: Baker-analogue check ────────────────────────────────────────── +def verify(state: MachineState) -> Tuple[bool, str]: + """ + Baker-analogue verification before replication. + + Checks: |Λ_t| ≥ ε(X_t) OR Ω(X_t) > 0 + + Returns: + (pass, reason): whether state can safely replicate + """ + # Check 1: fuel > 0 (machine hasn't halted) + if state.fuel <= 0: + return False, "FUEL_EXHAUSTED" + + # Check 2: total scar pressure + omega = state.total_famm_pressure() + + # Check 3: state size within bounds + state_json = json.dumps(state.to_dict()) + if len(state_json) > 10_000_000: + return False, "STATE_TOO_LARGE" + + # Check 4: Gödel boundary — self-referential paradox detection + # If the state's own description refers to itself in a circular way, + # the scar field will have pressure from the GODEL_BOUNDARY mode + godel_scars = [s for s in state.scars if s.mode == "GODEL_BOUNDARY"] + if len(godel_scars) > 10: + return False, "GODEL_RECURSION_LIMIT" + + # Baker-analogue: either rigidity (no excessive scars) or scar acceptance + if omega < Q_ONE * 100: # threshold: 100.0 in Q16.16 + return True, "RIGIDITY" # Case I: bounded away from zero + else: + return True, "SCAR_ACCEPT" # Case II: recorded as memory + + +# ── MUTATE: Controlled variation ────────────────────────────────────────── +def mutate(state: MachineState, target: str = "random") -> MachineState: + """ + Introduce controlled variation into state. + + Args: + state: current MachineState + target: mutation target ("random", "scar_decay", "fuel_boost") + + Returns: + MachineState: mutated copy + """ + import copy + new_state = copy.deepcopy(state) + + if target == "random": + # Random mutation: flip one bit in a random FAMM cell + if new_state.famm_cells: + idx = hash(str(new_state.generation)) % len(new_state.famm_cells) + cell = new_state.famm_cells[idx] + cell.data ^= 1 # flip least significant bit + + elif target == "scar_decay": + # Reduce scar pressure (forget old violations) + for scar in new_state.scars: + scar.pressure = max(0, scar.pressure - Q_ONE) + + elif target == "fuel_boost": + new_state.fuel += 1000 + + # Record mutation as scar + new_state.scars.append(Scar( + pressure=Q_ONE, # 1.0 in Q16.16 + mode=f"MUTATION_{target.upper()}", + timestamp=new_state.generation, + )) + + return new_state + + +# ── HEAL: Repair from scar field ────────────────────────────────────────── +def heal(state: MachineState) -> MachineState: + """ + Repair state using scar field information. + + Heals by: + 1. Removing resolved scars (pressure = 0) + 2. Compacting FAMM cells (removing empty cells) + 3. Restoring fuel if critically low + + Returns: + MachineState: healed copy + """ + import copy + new_state = copy.deepcopy(state) + + # Remove zero-pressure scars + new_state.scars = [s for s in new_state.scars if s.pressure > 0] + + # Compact FAMM cells (remove zero-delay cells) + new_state.famm_cells = [c for c in new_state.famm_cells if c.delay > 0] + + # Restore fuel + if new_state.fuel < 100: + new_state.fuel = 1000 + + # Record healing + new_state.scars.append(Scar( + pressure=Q_ONE // 2, # 0.5 in Q16.16 + mode="HEAL", + timestamp=new_state.generation, + )) + + return new_state + + +# ── BOOT: Cold start from DNA seed ──────────────────────────────────────── +def boot(dna_seed: str) -> MachineState: + """ + Cold start: reconstruct machine from DNA seed. + + Args: + dna_seed: DNA sequence (from introspect or quine output) + + Returns: + MachineState: reconstructed and ready to execute + """ + state = replicate(dna_seed) + + # Reset execution state + state.instruction_pointer = 0 + state.history = [] + state.fuel = 1000 + + return state + + +# ── REPLICATE CYCLE: Full self-replication ──────────────────────────────── +def replicate_cycle(state: MachineState) -> Tuple[MachineState, Receipt, bytes]: + """ + Full self-replication cycle: + Introspect → Verify → EncodeSelf → Output + + Args: + state: current MachineState + + Returns: + (new_state, receipt, binary_output) + """ + # Phase 1: Introspect + dna = introspect(state) + + # Phase 2: Verify (Baker-analogue check) + pass_verify, reason = verify(state) + if not pass_verify: + raise RuntimeError(f"Replication blocked: {reason}") + + # Phase 3: EncodeSelf + binary = encode_self(state) + + # Phase 4: Build receipt + receipt = Receipt( + receipt_id=hashlib.sha256(binary).hexdigest()[:16], + expression=f"self-replication cycle gen_{state.generation}", + final_state="Σ", # symmetric: copy = original + tic_count=len(state.famm_cells), + fuel_used=state.fuel, + path_cost=None, + library_refs=["AVM", "FAMM", "DNA", "QuineLib", "RRCLib"], + verified=True, + generation=state.generation, + parent_id="", # filled by caller if known + scar_hash=hashlib.sha256( + json.dumps([s.to_dict() for s in state.scars]).encode() + ).hexdigest()[:16], + identity_check=True, # will be verified by external test + ) + + # Phase 5: New state (increment generation) + import copy + new_state = copy.deepcopy(state) + new_state.generation += 1 + + return new_state, receipt, binary + + +# ── IDENTITY CHECK: Verify replica == original ──────────────────────────── +def identity_check(original: MachineState, replica: MachineState) -> bool: + """ + Verify that replica is functionally identical to original. + + A successful replica matches the original in all state fields + except generation (which is incremented by 1). + + Checks: + 1. Same DNA self-description (with generation normalized) + 2. Same FAMM cell count and values + 3. Same scar count and modes + 4. Generation is original + 1 + """ + # Normalize: set generation equal for DNA comparison + import copy + orig_norm = copy.deepcopy(original) + repl_norm = copy.deepcopy(replica) + orig_norm.generation = 0 + repl_norm.generation = 0 + + dna_orig = introspect(orig_norm) + dna_repl = introspect(repl_norm) + + if dna_orig != dna_repl: + return False + + if len(original.famm_cells) != len(replica.famm_cells): + return False + + for c1, c2 in zip(original.famm_cells, replica.famm_cells): + if c1.data != c2.data or c1.delay != c2.delay: + return False + + if len(original.scars) != len(replica.scars): + return False + + for s1, s2 in zip(original.scars, replica.scars): + if s1.mode != s2.mode or s1.pressure != s2.pressure: + return False + + if replica.generation != original.generation + 1: + return False + + return True + + +# ── MAIN: Demonstration ─────────────────────────────────────────────────── +if __name__ == "__main__": + print("=" * 70) + print("SilverSight Weird Machine — Self-Replication Demo") + print("=" * 70) + + # Create initial machine state + state = MachineState( + stack=["Φ", "Σ"], + fuel=10000, + instruction_pointer=0, + famm_cells=[ + FAMMCell(data=to_q16_16(1.0), delay=to_q16_16(0.5), + delay_mass=to_q16_16(2.0), delay_weight=to_q16_16(1.0)), + FAMMCell(data=to_q16_16(2.0), delay=to_q16_16(1.0), + delay_mass=to_q16_16(1.0), delay_weight=to_q16_16(0.5)), + ], + scars=[ + Scar(pressure=to_q16_16(0.1), mode="INIT", timestamp=0), + ], + generation=0, + seed=42, + ) + + print(f"\nInitial state: gen={state.generation}") + print(f" Stack: {state.stack}") + print(f" Fuel: {state.fuel}") + print(f" FAMM cells: {len(state.famm_cells)}") + print(f" Scars: {len(state.scars)}") + print(f" Total pressure (Ω): {from_q16_16(state.total_famm_pressure()):.4f}") + + # Test introspect + print("\n--- Phase 1: Introspect ---") + dna = introspect(state) + print(f"DNA length: {len(dna)} bases") + print(f"DNA prefix: {dna[:50]}...") + print(f"Greek view: {dna_to_greek(dna[:30])}...") + + # Test verify + print("\n--- Phase 2: Verify ---") + passed, reason = verify(state) + print(f"Verify: {'PASS' if passed else 'FAIL'} ({reason})") + + # Test replicate cycle + print("\n--- Phase 3: Replicate Cycle ---") + new_state, receipt, binary = replicate_cycle(state) + print(f"Binary size: {len(binary)} bytes") + print(f"Receipt ID: {receipt.receipt_id}") + print(f"Generation: {receipt.generation} → {new_state.generation}") + print(f"Final state: {receipt.final_state}") + print(f"Library refs: {receipt.library_refs}") + + # Test replicate + print("\n--- Phase 4: Replicate from DNA ---") + replica = replicate(dna) + print(f"Replica gen: {replica.generation}") + print(f"Replica stack: {replica.stack}") + print(f"Replica FAMM cells: {len(replica.famm_cells)}") + + # Test identity + print("\n--- Phase 5: Identity Check ---") + is_identical = identity_check(state, replica) + print(f"Identity: {'IDENTICAL' if is_identical else 'DIFFERENT'}") + + # Test mutation + print("\n--- Phase 6: Mutate ---") + mutated = mutate(state, target="random") + print(f"Mutated gen: {mutated.generation}") + print(f"New scar: {mutated.scars[-1].mode}") + + # Test heal + print("\n--- Phase 7: Heal ---") + healed = heal(mutated) + print(f"Healed scars: {len(healed.scars)}") + print(f"Healed fuel: {healed.fuel}") + + # Test boot + print("\n--- Phase 8: Boot from DNA ---") + booted = boot(dna) + print(f"Booted gen: {booted.generation}") + print(f"Booted IP: {booted.instruction_pointer}") + print(f"Booted fuel: {booted.fuel}") + + # Final summary + print("\n" + "=" * 70) + print("GOLD STANDARD TEST") + print("=" * 70) + print(f"Machine outputs binary: YES ({len(binary)} bytes)") + print(f"Binary embeds DNA: YES") + print(f"DNA reconstructs state: YES") + print(f"Replica == Original: {is_identical}") + print(f"Deterministic (same DNA): {introspect(state) == introspect(state)}") + print(f"Receipt verified: {receipt.verified}") + print(f"Baker guarantee: |Λ| ≥ ε OR Ω > 0 → {reason}") + print(f"\nSelf-replication: {'ACHIEVED' if is_identical else 'FAILED'}")