Delete test_self_modifying.py with huggingface_hub

test_self_modifying.py

@@ -1,706 +0,0 @@
-"""
-TEST #7: Self-Modifying Code
-=============================
-Write a program that modifies its own instructions in memory,
-then executes the modified code correctly.
-
-A skeptic would demand: "Prove your CPU handles self-modification.
-Show instruction fetch after memory write sees the new value."
-
-This test implements a simple Von Neumann architecture simulation
-using threshold circuits for all operations.
-"""
-
-import torch
-from safetensors.torch import load_file
-
-# Load circuits
-model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-# =============================================================================
-# INSTRUCTION SET DEFINITION
-# =============================================================================
-"""
-Simple 8-bit instruction format:
-  [7:4] = opcode (16 possible operations)
-  [3:0] = operand (immediate value or register select)
-
-Opcodes:
-  0x0 = NOP          No operation
-  0x1 = LOAD_IMM     R0 = operand (immediate load)
-  0x2 = ADD_IMM      R0 = R0 + operand
-  0x3 = SUB_IMM      R0 = R0 - operand
-  0x4 = STORE        MEM[operand] = R0
-  0x5 = LOAD         R0 = MEM[operand]
-  0x6 = JMP          PC = operand
-  0x7 = JZ           if R0 == 0: PC = operand
-  0x8 = HALT         Stop execution
-  0x9 = XOR_IMM      R0 = R0 XOR operand
-  0xA = AND_IMM      R0 = R0 AND operand
-  0xB = INC          R0 = R0 + 1
-  0xC = DEC          R0 = R0 - 1
-  0xD = MOV_TO_R1    R1 = R0
-  0xE = ADD_R1       R0 = R0 + R1
-  0xF = STORE_CODE   CODE[operand] = R0 (self-modify!)
-"""
-
-OPCODES = {
-    0x0: 'NOP',
-    0x1: 'LOAD_IMM',
-    0x2: 'ADD_IMM',
-    0x3: 'SUB_IMM',
-    0x4: 'STORE',
-    0x5: 'LOAD',
-    0x6: 'JMP',
-    0x7: 'JZ',
-    0x8: 'HALT',
-    0x9: 'XOR_IMM',
-    0xA: 'AND_IMM',
-    0xB: 'INC',
-    0xC: 'DEC',
-    0xD: 'MOV_TO_R1',
-    0xE: 'ADD_R1',
-    0xF: 'STORE_CODE',
-}
-
-def make_instr(opcode, operand):
-    """Create instruction byte from opcode and operand."""
-    return ((opcode & 0xF) << 4) | (operand & 0xF)
-
-# =============================================================================
-# CIRCUIT PRIMITIVES
-# =============================================================================
-
-def eval_xor_arith(inp, prefix):
-    """Evaluate XOR for arithmetic circuits."""
-    w1_or = model[f'{prefix}.layer1.or.weight']
-    b1_or = model[f'{prefix}.layer1.or.bias']
-    w1_nand = model[f'{prefix}.layer1.nand.weight']
-    b1_nand = model[f'{prefix}.layer1.nand.bias']
-    w2 = model[f'{prefix}.layer2.weight']
-    b2 = model[f'{prefix}.layer2.bias']
-    h_or = heaviside(inp @ w1_or + b1_or)
-    h_nand = heaviside(inp @ w1_nand + b1_nand)
-    hidden = torch.tensor([h_or.item(), h_nand.item()])
-    return heaviside(hidden @ w2 + b2).item()
-
-def eval_full_adder(a, b, cin, prefix):
-    """Evaluate full adder."""
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-    w_c1 = model[f'{prefix}.ha1.carry.weight']
-    b_c1 = model[f'{prefix}.ha1.carry.bias']
-    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-    w_c2 = model[f'{prefix}.ha2.carry.weight']
-    b_c2 = model[f'{prefix}.ha2.carry.bias']
-    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    w_or = model[f'{prefix}.carry_or.weight']
-    b_or = model[f'{prefix}.carry_or.bias']
-    cout = heaviside(inp_cout @ w_or + b_or).item()
-    return int(ha2_sum), int(cout)
-
-def circuit_add(a, b):
-    """8-bit addition using threshold circuits."""
-    carry = 0.0
-    result_bits = []
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        s, carry = eval_full_adder(float(a_bit), float(b_bit), carry,
-                                    f'arithmetic.ripplecarry8bit.fa{i}')
-        result_bits.append(s)
-    return sum(result_bits[i] * (2**i) for i in range(8))
-
-def circuit_sub(a, b):
-    """8-bit subtraction using threshold circuits (a - b)."""
-    not_b = (~b) & 0xFF
-    temp = circuit_add(a, not_b)
-    return circuit_add(temp, 1)
-
-def circuit_xor_byte(a, b):
-    """XOR two bytes using threshold circuits."""
-    result = 0
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        inp = torch.tensor([float(a_bit), float(b_bit)])
-        w1_n1 = model['boolean.xor.layer1.neuron1.weight']
-        b1_n1 = model['boolean.xor.layer1.neuron1.bias']
-        w1_n2 = model['boolean.xor.layer1.neuron2.weight']
-        b1_n2 = model['boolean.xor.layer1.neuron2.bias']
-        w2 = model['boolean.xor.layer2.weight']
-        b2 = model['boolean.xor.layer2.bias']
-        h1 = heaviside(inp @ w1_n1 + b1_n1)
-        h2 = heaviside(inp @ w1_n2 + b1_n2)
-        hidden = torch.tensor([h1.item(), h2.item()])
-        out = int(heaviside(hidden @ w2 + b2).item())
-        result |= (out << i)
-    return result
-
-def circuit_and_byte(a, b):
-    """AND two bytes using threshold circuits."""
-    result = 0
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        inp = torch.tensor([float(a_bit), float(b_bit)])
-        w = model['boolean.and.weight']
-        bias = model['boolean.and.bias']
-        out = int(heaviside(inp @ w + bias).item())
-        result |= (out << i)
-    return result
-
-def circuit_eq_zero(val):
-    """Check if byte equals zero using threshold circuits."""
-    # Zero when no bits are set
-    # Use NOR-like logic: output 1 only if all inputs are 0
-    for i in range(8):
-        if (val >> i) & 1:
-            return 0
-    return 1
-
-# =============================================================================
-# CPU SIMULATOR
-# =============================================================================
-
-class ThresholdCPU:
-    """
-    Simple CPU that uses threshold circuits for all operations.
-    Features Von Neumann architecture with self-modifying code support.
-    """
-
-    def __init__(self, code, trace=False):
-        """
-        Initialize CPU with code.
-        code: list of instruction bytes (max 16 bytes, addresses 0-15)
-        """
-        self.code = list(code) + [0] * (16 - len(code))  # Pad to 16
-        self.memory = [0] * 16  # 16 bytes of data memory
-        self.r0 = 0  # Accumulator
-        self.r1 = 0  # Secondary register
-        self.pc = 0  # Program counter
-        self.halted = False
-        self.trace = trace
-        self.cycle_count = 0
-        self.max_cycles = 1000  # Prevent infinite loops
-
-        # Execution trace for verification
-        self.execution_log = []
-
-    def fetch(self):
-        """Fetch instruction at PC."""
-        if self.pc < 0 or self.pc >= 16:
-            self.halted = True
-            return 0
-        return self.code[self.pc]
-
-    def decode(self, instr):
-        """Decode instruction into opcode and operand."""
-        opcode = (instr >> 4) & 0xF
-        operand = instr & 0xF
-        return opcode, operand
-
-    def execute_one(self):
-        """Execute one instruction cycle."""
-        if self.halted:
-            return False
-
-        if self.cycle_count >= self.max_cycles:
-            if self.trace:
-                print(f"  MAX CYCLES REACHED")
-            self.halted = True
-            return False
-
-        # Fetch
-        instr = self.fetch()
-        opcode, operand = self.decode(instr)
-        op_name = OPCODES.get(opcode, '???')
-
-        old_pc = self.pc
-        old_r0 = self.r0
-
-        # Execute
-        if opcode == 0x0:  # NOP
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x1:  # LOAD_IMM
-            self.r0 = operand
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x2:  # ADD_IMM
-            self.r0 = circuit_add(self.r0, operand)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x3:  # SUB_IMM
-            self.r0 = circuit_sub(self.r0, operand)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x4:  # STORE
-            self.memory[operand] = self.r0
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x5:  # LOAD
-            self.r0 = self.memory[operand]
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x6:  # JMP
-            self.pc = operand
-
-        elif opcode == 0x7:  # JZ
-            if circuit_eq_zero(self.r0):
-                self.pc = operand
-            else:
-                self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x8:  # HALT
-            self.halted = True
-
-        elif opcode == 0x9:  # XOR_IMM
-            self.r0 = circuit_xor_byte(self.r0, operand)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xA:  # AND_IMM
-            self.r0 = circuit_and_byte(self.r0, operand)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xB:  # INC
-            self.r0 = circuit_add(self.r0, 1)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xC:  # DEC
-            self.r0 = circuit_sub(self.r0, 1)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xD:  # MOV_TO_R1
-            self.r1 = self.r0
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xE:  # ADD_R1
-            self.r0 = circuit_add(self.r0, self.r1)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xF:  # STORE_CODE (self-modify!)
-            self.code[operand] = self.r0
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        # Log execution
-        log_entry = {
-            'cycle': self.cycle_count,
-            'pc': old_pc,
-            'instr': instr,
-            'op': op_name,
-            'operand': operand,
-            'r0_before': old_r0,
-            'r0_after': self.r0,
-        }
-        self.execution_log.append(log_entry)
-
-        if self.trace:
-            print(f"  [{self.cycle_count:3d}] PC={old_pc:2d} {op_name:12s} {operand:2d}  "
-                  f"R0: {old_r0:3d} -> {self.r0:3d}")
-
-        self.cycle_count += 1
-        return not self.halted
-
-    def run(self):
-        """Run until halted."""
-        while self.execute_one():
-            pass
-        return self.r0
-
-# =============================================================================
-# SELF-MODIFYING CODE TESTS
-# =============================================================================
-
-def test_basic_execution():
-    """Verify basic instruction execution works."""
-    print("\n[TEST 1] Basic Instruction Execution")
-    print("-" * 60)
-
-    # Simple program: LOAD 5, ADD 3, HALT -> R0 = 8
-    code = [
-        make_instr(0x1, 5),   # LOAD_IMM 5
-        make_instr(0x2, 3),   # ADD_IMM 3
-        make_instr(0x8, 0),   # HALT
-    ]
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    expected = 8
-    print(f"\n  Result: R0 = {result}, expected {expected}")
-
-    if result == expected:
-        print("  PASSED: Basic execution works")
-        return True
-    else:
-        print("  FAILED: Incorrect result")
-        return False
-
-def test_self_modify_simple():
-    """
-    Self-modifying code: change an instruction, then execute it.
-    """
-    print("\n[TEST 2] Simple Self-Modification")
-    print("-" * 60)
-
-    # Program:
-    # 0: LOAD_IMM 7       ; R0 = 7
-    # 1: STORE_CODE 3     ; CODE[3] = 7 (was NOP, becomes something)
-    # 2: JMP 3            ; Jump to modified instruction
-    # 3: NOP              ; Will be overwritten to 0x07 = JZ (but R0=7, won't jump)
-    #                     ; Actually 0x07 = JZ 7, which jumps to addr 7 if R0==0
-    #                     ; But R0=7, so no jump, falls through to...
-    # 4: HALT
-
-    # Actually, let's make it simpler and more verifiable:
-    # We'll write an ADD_IMM instruction
-
-    # 0: LOAD_IMM 5       ; R0 = 5
-    # 1: MOV_TO_R1        ; R1 = 5
-    # 2: LOAD_IMM 0x23    ; R0 = 0x23 = ADD_IMM 3 instruction
-    # 3: STORE_CODE 6     ; CODE[6] = 0x23 (ADD_IMM 3)
-    # 4: LOAD_IMM 10      ; R0 = 10
-    # 5: JMP 6            ; Jump to modified instruction
-    # 6: NOP              ; Will become ADD_IMM 3
-    # 7: HALT
-
-    code = [
-        make_instr(0x1, 5),    # 0: LOAD_IMM 5
-        make_instr(0xD, 0),    # 1: MOV_TO_R1 (R1 = 5)
-        make_instr(0x1, 0x2),  # 2: LOAD_IMM 2 (partial - need two steps)
-        make_instr(0x2, 1),    # 3: ADD_IMM 1 -> R0 = 3
-        # Now R0 = 3, we want instruction 0x23 = ADD_IMM 3
-        # 0x23 = 0010 0011 = opcode 2, operand 3
-        # Let's construct it: LOAD_IMM can only do 0-15
-        # We need R0 = 0x23 = 35
-    ]
-
-    # Simpler approach: just modify NOP to become INC
-    # INC = 0xB0 = 176, too big for immediate
-    # Let's use: modify to LOAD_IMM 9
-
-    # Simplest: patch an instruction at runtime
-    # Program that patches itself to add more:
-
-    # 0: LOAD_IMM 10      ; R0 = 10
-    # 1: STORE_CODE 4     ; CODE[4] = 10 (interpret as instruction 0x0A = AND_IMM 0)
-    # 2: LOAD_IMM 15      ; R0 = 15
-    # 3: JMP 4            ; Jump to patched location
-    # 4: NOP              ; Will become AND_IMM 0 (R0 = R0 AND 0 = 0)
-    # 5: HALT             ; But we're jumping to 4, then 5
-
-    # Wait, 10 = 0x0A = AND_IMM 10? Let me recheck
-    # 10 = 0b00001010 = opcode 0, operand 10 = NOP with weird operand = still NOP
-
-    # Let's use 0x1F = 31 = LOAD_IMM 15
-    # 31 = 0b00011111 = opcode 1, operand 15 = LOAD_IMM 15
-
-    code = [
-        make_instr(0x1, 0xF),  # 0: LOAD_IMM 15 -> R0 = 15
-        make_instr(0x2, 0xF),  # 1: ADD_IMM 15 -> R0 = 30
-        make_instr(0x2, 0x1),  # 2: ADD_IMM 1 -> R0 = 31 = 0x1F = LOAD_IMM 15
-        make_instr(0xF, 0x6),  # 3: STORE_CODE 6 -> CODE[6] = 31
-        make_instr(0x1, 0x0),  # 4: LOAD_IMM 0 -> R0 = 0
-        make_instr(0x6, 0x6),  # 5: JMP 6
-        make_instr(0x0, 0x0),  # 6: NOP (will become LOAD_IMM 15)
-        make_instr(0x8, 0x0),  # 7: HALT
-    ]
-
-    print("  Program:")
-    print("    0: LOAD_IMM 15      ; R0 = 15")
-    print("    1: ADD_IMM 15       ; R0 = 30")
-    print("    2: ADD_IMM 1        ; R0 = 31 (= LOAD_IMM 15 instruction)")
-    print("    3: STORE_CODE 6     ; Patch CODE[6] = 31")
-    print("    4: LOAD_IMM 0       ; R0 = 0")
-    print("    5: JMP 6            ; Execute patched instruction")
-    print("    6: NOP              ; (becomes LOAD_IMM 15)")
-    print("    7: HALT")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-
-    # Record code before
-    code_before = cpu.code[6]
-    print(f"\n  CODE[6] before: {code_before} (0x{code_before:02x}) = {OPCODES.get(code_before >> 4, '?')}")
-
-    result = cpu.run()
-
-    code_after = cpu.code[6]
-    print(f"  CODE[6] after:  {code_after} (0x{code_after:02x}) = {OPCODES.get(code_after >> 4, '?')}")
-    print(f"\n  Final R0 = {result}")
-
-    # If self-modification worked:
-    # - CODE[6] should have been patched from 0 to 31
-    # - After JMP 6, LOAD_IMM 15 executes, setting R0 = 15
-    # - Then HALT at address 7
-
-    expected = 15
-    code_modified = (code_after == 31)
-    result_correct = (result == expected)
-
-    if code_modified and result_correct:
-        print("  PASSED: Self-modification executed correctly")
-        return True
-    else:
-        if not code_modified:
-            print(f"  FAILED: CODE[6] not modified (expected 31, got {code_after})")
-        if not result_correct:
-            print(f"  FAILED: Wrong result (expected {expected}, got {result})")
-        return False
-
-def test_self_modify_loop():
-    """
-    Self-modifying loop: program modifies its own loop counter.
-    """
-    print("\n[TEST 3] Self-Modifying Loop")
-    print("-" * 60)
-
-    # Program that counts down by modifying its own counter instruction
-    # The "counter" is embedded as the operand of a LOAD_IMM instruction
-
-    # 0: NOP              ; Placeholder (will be LOAD_IMM n)
-    # 1: JZ 5             ; If R0 == 0, exit to HALT
-    # 2: DEC              ; R0 = R0 - 1
-    # 3: STORE_CODE 0     ; CODE[0] = R0 (new LOAD_IMM R0)
-    # 4: JMP 0            ; Loop
-    # 5: HALT
-
-    # Start with LOAD_IMM 3 at address 0
-    code = [
-        make_instr(0x1, 0x3),  # 0: LOAD_IMM 3
-        make_instr(0x7, 0x5),  # 1: JZ 5
-        make_instr(0xC, 0x0),  # 2: DEC
-        make_instr(0xF, 0x0),  # 3: STORE_CODE 0
-        make_instr(0x6, 0x0),  # 4: JMP 0
-        make_instr(0x8, 0x0),  # 5: HALT
-    ]
-
-    print("  Program: Self-modifying countdown")
-    print("    Counter embedded in instruction at address 0")
-    print("    Each iteration: DEC, write back to CODE[0], loop")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    # Should loop: 3 -> 2 -> 1 -> 0 -> exit
-    # Final R0 = 0
-
-    expected = 0
-    expected_cycles = 15  # Approximately
-
-    print(f"\n  Final R0 = {result}")
-    print(f"  Cycles: {cpu.cycle_count}")
-
-    # Verify CODE[0] was modified each iteration
-    final_code_0 = cpu.code[0]
-    print(f"  CODE[0] final: {final_code_0} (0x{final_code_0:02x})")
-
-    if result == expected:
-        print("  PASSED: Self-modifying loop executed correctly")
-        return True
-    else:
-        print(f"  FAILED: Expected R0 = {expected}, got {result}")
-        return False
-
-def test_code_generation():
-    """
-    Program generates new code at runtime and executes it.
-    """
-    print("\n[TEST 4] Runtime Code Generation")
-    print("-" * 60)
-
-    # Program that:
-    # 1. Computes an instruction (LOAD_IMM 7) from parts
-    # 2. Writes it to memory
-    # 3. Jumps to execute it
-
-    # LOAD_IMM 7 = 0x17 = 23
-    # Build 23 from: 15 + 8 = 23
-
-    code = [
-        make_instr(0x1, 0xF),  # 0: LOAD_IMM 15
-        make_instr(0x2, 0x8),  # 1: ADD_IMM 8 -> R0 = 23 = LOAD_IMM 7
-        make_instr(0xF, 0x6),  # 2: STORE_CODE 6
-        make_instr(0x1, 0x0),  # 3: LOAD_IMM 0 (clear R0)
-        make_instr(0x6, 0x6),  # 4: JMP 6
-        make_instr(0x8, 0x0),  # 5: HALT (unreached)
-        make_instr(0x0, 0x0),  # 6: NOP (becomes LOAD_IMM 7)
-        make_instr(0x8, 0x0),  # 7: HALT
-    ]
-
-    print("  Program: Generate LOAD_IMM 7 instruction at runtime")
-    print("    15 + 8 = 23 = 0x17 = LOAD_IMM 7")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    expected = 7
-    print(f"\n  Final R0 = {result}, expected {expected}")
-
-    if result == expected:
-        print("  PASSED: Runtime code generation works")
-        return True
-    else:
-        print("  FAILED: Wrong result")
-        return False
-
-def test_polymorphic_code():
-    """
-    Code that changes its own behavior based on input.
-    """
-    print("\n[TEST 5] Polymorphic Code")
-    print("-" * 60)
-
-    # Program that modifies itself to either ADD or SUB based on a flag
-
-    # Initial: flag in MEM[0], operation at CODE[4]
-    # If MEM[0] == 0: CODE[4] = ADD_IMM 5 (0x25 = 37)
-    # If MEM[0] != 0: CODE[4] = SUB_IMM 5 (0x35 = 53)
-
-    # Simplified: just demonstrate the modification mechanism
-
-    # Store test value in memory first
-    code = [
-        make_instr(0x1, 0x0),  # 0: LOAD_IMM 0 (flag = 0)
-        make_instr(0x4, 0x0),  # 1: STORE 0 (MEM[0] = 0)
-        make_instr(0x1, 0x2),  # 2: LOAD_IMM 2
-        make_instr(0x2, 0x3),  # 3: ADD_IMM 3 -> R0 = 5 = initial value
-        # Now decide: ADD or SUB?
-        # For simplicity, we'll just patch to ADD_IMM 3
-        make_instr(0x1, 0x2),  # 4: LOAD_IMM 2 (opcode for ADD_IMM, will build 0x23)
-        make_instr(0x2, 0x1),  # 5: ADD_IMM 1 -> R0 = 3
-        make_instr(0x2, 0xF),  # 6: ADD_IMM 15 -> R0 = 18
-        make_instr(0x2, 0xF),  # 7: ADD_IMM 15 -> R0 = 33
-        make_instr(0x2, 0x2),  # 8: ADD_IMM 2 -> R0 = 35 = 0x23 = ADD_IMM 3
-        make_instr(0xF, 0xC),  # 9: STORE_CODE 12
-        make_instr(0x1, 0xA),  # 10: LOAD_IMM 10 (base value)
-        make_instr(0x6, 0xC),  # 11: JMP 12
-        make_instr(0x0, 0x0),  # 12: NOP (becomes ADD_IMM 3)
-        make_instr(0x8, 0x0),  # 13: HALT
-    ]
-
-    print("  Program: Build ADD_IMM 3 instruction (0x23 = 35)")
-    print("    Then execute it on base value 10 -> expect 13")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    expected = 13  # 10 + 3
-    print(f"\n  Final R0 = {result}, expected {expected}")
-
-    if result == expected:
-        print("  PASSED: Polymorphic code modification works")
-        return True
-    else:
-        print("  FAILED: Wrong result")
-        return False
-
-def test_quine_like():
-    """
-    Program that reads its own code and verifies it.
-    """
-    print("\n[TEST 6] Code Self-Reading (Quine-like)")
-    print("-" * 60)
-
-    # This test verifies the CPU can read code memory via STORE_CODE/execution
-    # by having a program that modifies itself to effectively "read" code values
-
-    # Simple verification: execute an instruction, modify it to NOP,
-    # verify the modification took effect
-
-    code = [
-        make_instr(0x1, 0x7),  # 0: LOAD_IMM 7
-        make_instr(0x2, 0x3),  # 1: ADD_IMM 3 -> R0 = 10
-        make_instr(0x4, 0x0),  # 2: STORE 0 (MEM[0] = 10, save result)
-        make_instr(0x1, 0x0),  # 3: LOAD_IMM 0 (NOP instruction = 0x00)
-        make_instr(0xF, 0x1),  # 4: STORE_CODE 1 (patch out ADD_IMM 3)
-        make_instr(0x6, 0x0),  # 5: JMP 0 (re-execute from start)
-        # Second pass: ADD_IMM 3 is now NOP, so R0 = 7
-        # But wait, this creates infinite loop...
-    ]
-
-    # Simpler: verify code was modified by checking final state
-
-    code = [
-        make_instr(0x1, 0x5),  # 0: LOAD_IMM 5
-        make_instr(0xD, 0x0),  # 1: MOV_TO_R1 (R1 = 5)
-        make_instr(0x1, 0x0),  # 2: LOAD_IMM 0 (NOP = 0x00)
-        make_instr(0xF, 0x7),  # 3: STORE_CODE 7 (patch instruction at 7)
-        make_instr(0x1, 0x9),  # 4: LOAD_IMM 9
-        make_instr(0x6, 0x7),  # 5: JMP 7
-        make_instr(0x8, 0x0),  # 6: HALT (not reached directly)
-        make_instr(0xB, 0x0),  # 7: INC (will be patched to NOP)
-        make_instr(0x8, 0x0),  # 8: HALT
-    ]
-
-    print("  Program: Patch INC instruction to NOP")
-    print("    Original: LOAD_IMM 9, (INC), HALT -> expect 10")
-    print("    Patched:  LOAD_IMM 9, (NOP), HALT -> expect 9")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    # Without patch: 9 + 1 = 10
-    # With patch (INC -> NOP): 9
-    expected = 9
-
-    print(f"\n  Final R0 = {result}, expected {expected}")
-    print(f"  CODE[7] final = {cpu.code[7]} (was INC=0xB0, now NOP=0x00)")
-
-    if result == expected and cpu.code[7] == 0:
-        print("  PASSED: Successfully patched and executed modified code")
-        return True
-    else:
-        print("  FAILED")
-        return False
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #7: SELF-MODIFYING CODE")
-    print(" Programs that modify their own instructions at runtime")
-    print("=" * 70)
-
-    results = []
-
-    results.append(("Basic execution", test_basic_execution()))
-    results.append(("Simple self-modify", test_self_modify_simple()))
-    results.append(("Self-modifying loop", test_self_modify_loop()))
-    results.append(("Runtime code gen", test_code_generation()))
-    results.append(("Polymorphic code", test_polymorphic_code()))
-    results.append(("Code self-reading", test_quine_like()))
-
-    print("\n" + "=" * 70)
-    print(" SUMMARY")
-    print("=" * 70)
-
-    passed = sum(1 for _, r in results if r)
-    total = len(results)
-
-    for name, r in results:
-        status = "PASS" if r else "FAIL"
-        print(f"  {name:25s} [{status}]")
-
-    print(f"\n  Total: {passed}/{total} tests passed")
-
-    if passed == total:
-        print("\n  STATUS: SELF-MODIFYING CODE VERIFIED")
-        print("          The CPU correctly handles runtime code modification.")
-    else:
-        print("\n  STATUS: SOME SELF-MODIFICATION TESTS FAILED")
-
-    print("=" * 70)