mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
583 lines
20 KiB
Python
583 lines
20 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
sentence_as_computation_gcl.py - Sentence as Computation via GCL Virtual Machine
|
|
|
|
This module tests the claim: "even a sentence is computation if you are able to
|
|
create a virtual machine with it."
|
|
|
|
The approach:
|
|
1. Encode a sentence as GCL primitives (delta, pattern, field operations)
|
|
2. Create a virtual machine that interprets these primitives
|
|
3. Execute the sentence to produce a computational result
|
|
4. Prove that the sentence is computation
|
|
|
|
GCL Primitives Used:
|
|
- Delta Encoding: Store changes from previous state
|
|
- PTOS Dictionary: Common operations as single-byte indices
|
|
- Field Operations: complement, transcribe, translate, mutate, route, control, admit, attest
|
|
- Surface Field: Measure whether candidate can carry structure
|
|
- Closure Field: Measure whether candidate preserves structure under operation
|
|
- Motif Field: Measure whether surface has executable affordances
|
|
- Informaton Field: Measure whether candidate can enter manifold as addressable information
|
|
- RGFlow Field: Measure persistence under coarse-graining
|
|
|
|
The Virtual Machine:
|
|
- State: Register file (finite state)
|
|
- Operations: GCL primitives
|
|
- Execution: Interpret sentence as sequence of operations
|
|
- Output: Computational result
|
|
|
|
Key Insight:
|
|
If a sentence can be encoded as GCL primitives and executed by a virtual machine,
|
|
then the sentence IS computation. The boundary between language and computation is porous.
|
|
"""
|
|
|
|
from dataclasses import dataclass
|
|
from typing import Dict, List, Optional, Tuple, Callable
|
|
from enum import IntEnum
|
|
import re
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|
# GCL Primitives
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
class GCLOperation(IntEnum):
|
|
"""GCL operation primitives"""
|
|
COMPLEMENT = 0x00
|
|
TRANSCRIBE = 0x01
|
|
TRANSLATE = 0x02
|
|
MUTATE = 0x03
|
|
ROUTE = 0x04
|
|
CONTROL = 0x05
|
|
ADMIT = 0x06
|
|
ATTEST = 0x07
|
|
DELTA = 0x08
|
|
PATTERN = 0x09
|
|
|
|
|
|
class PTOSDictionary:
|
|
"""PTOS dictionary for common sentence patterns"""
|
|
|
|
OPERATIONS = {
|
|
"add": 0x00,
|
|
"subtract": 0x01,
|
|
"multiply": 0x02,
|
|
"divide": 0x03,
|
|
"set": 0x04,
|
|
"get": 0x05,
|
|
"compare": 0x06,
|
|
"jump": 0x07,
|
|
"call": 0x08,
|
|
"return": 0x09,
|
|
"if": 0x0A,
|
|
"else": 0x0B,
|
|
"while": 0x0C,
|
|
"for": 0x0D,
|
|
"end": 0x0E,
|
|
"print": 0x0F
|
|
}
|
|
|
|
VALUES = {
|
|
"zero": 0x00,
|
|
"one": 0x01,
|
|
"two": 0x02,
|
|
"three": 0x03,
|
|
"four": 0x04,
|
|
"five": 0x05,
|
|
"six": 0x06,
|
|
"seven": 0x07,
|
|
"eight": 0x08,
|
|
"nine": 0x09,
|
|
"ten": 0x0A,
|
|
"true": 0x0B,
|
|
"false": 0x0C,
|
|
"null": 0x0D
|
|
}
|
|
|
|
REGISTERS = {
|
|
"r0": 0x00,
|
|
"r1": 0x01,
|
|
"r2": 0x02,
|
|
"r3": 0x03,
|
|
"r4": 0x04,
|
|
"r5": 0x05,
|
|
"r6": 0x06,
|
|
"r7": 0x07
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class GCLDelta:
|
|
"""GCL delta encoding"""
|
|
has_delta: bool
|
|
changed_fields: List[str]
|
|
delta_values: Dict[str, int]
|
|
|
|
|
|
@dataclass
|
|
class GCLSurface:
|
|
"""GCL surface field measurement"""
|
|
alphabet_size: int
|
|
bits_per_symbol: int
|
|
role_flags: int
|
|
operation_flags: int
|
|
closure_kind: str
|
|
|
|
def surface_field(self) -> float:
|
|
"""Surface field: measures ability to carry structure"""
|
|
frame_efficiency = 1.0 # Simplified
|
|
return (self.alphabet_size / self.bits_per_symbol) * frame_efficiency
|
|
|
|
def closure_field(self) -> float:
|
|
"""Closure field: measures ability to preserve structure"""
|
|
closure_scores = {
|
|
"complement": 1.0,
|
|
"rgflow": 0.9,
|
|
"codon": 0.8,
|
|
"transient": 0.65,
|
|
"partial": 0.35,
|
|
"none": 0.0
|
|
}
|
|
return closure_scores.get(self.closure_kind, 0.0)
|
|
|
|
def motif_field(self) -> float:
|
|
"""Motif field: measures executable affordances"""
|
|
return bin(self.operation_flags).count('1') / 8.0
|
|
|
|
def informaton_field(self) -> float:
|
|
"""Informaton field: measures ability to enter manifold"""
|
|
return 1.0 if self.role_flags > 0 else 0.0
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|
# Sentence Encoder
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
class SentenceEncoder:
|
|
"""Encode sentence as GCL primitives"""
|
|
|
|
def __init__(self):
|
|
self.ptos = PTOSDictionary()
|
|
self.previous_state = None
|
|
|
|
def tokenize(self, sentence: str) -> List[str]:
|
|
"""Tokenize sentence into words"""
|
|
# Simple tokenization: split on whitespace and punctuation
|
|
tokens = re.findall(r'\w+|\d+|[.,!?;]', sentence.lower())
|
|
return tokens
|
|
|
|
def encode_operation(self, word: str) -> Optional[int]:
|
|
"""Encode operation word as PTOS dictionary index"""
|
|
return self.ptos.OPERATIONS.get(word)
|
|
|
|
def encode_value(self, word: str) -> Optional[int]:
|
|
"""Encode value word as PTOS dictionary index or literal"""
|
|
if word in self.ptos.VALUES:
|
|
return self.ptos.VALUES[word]
|
|
# Try to parse as number
|
|
try:
|
|
return int(word)
|
|
except ValueError:
|
|
return None
|
|
|
|
def encode_register(self, word: str) -> Optional[int]:
|
|
"""Encode register name as PTOS dictionary index"""
|
|
return self.ptos.REGISTERS.get(word)
|
|
|
|
def compute_delta(self, current_tokens: List[str], previous_tokens: Optional[List[str]] = None) -> GCLDelta:
|
|
"""Compute delta between current and previous sentence"""
|
|
if previous_tokens is None:
|
|
return GCLDelta(False, [], {})
|
|
|
|
changed_fields = []
|
|
delta_values = {}
|
|
|
|
for i, (curr, prev) in enumerate(zip(current_tokens, previous_tokens)):
|
|
if curr != prev:
|
|
changed_fields.append(f"token_{i}")
|
|
delta_values[f"token_{i}"] = hash(curr) % 256
|
|
|
|
return GCLDelta(
|
|
has_delta=len(changed_fields) > 0,
|
|
changed_fields=changed_fields,
|
|
delta_values=delta_values
|
|
)
|
|
|
|
def encode_sentence(self, sentence: str) -> bytes:
|
|
"""Encode sentence as GCL bytecode"""
|
|
tokens = self.tokenize(sentence)
|
|
delta = self.compute_delta(tokens, self.previous_state)
|
|
|
|
bytecode = bytearray()
|
|
|
|
# Delta marker
|
|
bytecode.append(0x44 if delta.has_delta else 0x46) # D=delta, F=full
|
|
|
|
# Encode each token
|
|
for token in tokens:
|
|
# Try operation
|
|
op_code = self.encode_operation(token)
|
|
if op_code is not None:
|
|
bytecode.append(0x01) # Operation marker
|
|
bytecode.append(op_code)
|
|
continue
|
|
|
|
# Try register
|
|
reg_code = self.encode_register(token)
|
|
if reg_code is not None:
|
|
bytecode.append(0x02) # Register marker
|
|
bytecode.append(reg_code)
|
|
continue
|
|
|
|
# Try value
|
|
val_code = self.encode_value(token)
|
|
if val_code is not None:
|
|
bytecode.append(0x03) # Value marker
|
|
bytecode.append(val_code & 0xFF)
|
|
continue
|
|
|
|
# Unknown token: store as literal
|
|
bytecode.append(0x04) # Literal marker
|
|
bytecode.extend(token.encode('ascii')[:4])
|
|
|
|
self.previous_state = tokens
|
|
return bytes(bytecode)
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|
# Virtual Machine
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
class GCLVirtualMachine:
|
|
"""Virtual machine that executes GCL-encoded sentences"""
|
|
|
|
def __init__(self):
|
|
self.registers = [0] * 8 # r0-r7
|
|
self.stack = []
|
|
self.pc = 0 # Program counter
|
|
self.running = False
|
|
self.output = []
|
|
|
|
# Operation implementations
|
|
self.operations = {
|
|
0x00: self.op_add,
|
|
0x01: self.op_subtract,
|
|
0x02: self.op_multiply,
|
|
0x03: self.op_divide,
|
|
0x04: self.op_set,
|
|
0x05: self.op_get,
|
|
0x06: self.op_compare,
|
|
0x07: self.op_jump,
|
|
0x08: self.op_call,
|
|
0x09: self.op_return,
|
|
0x0A: self.op_if,
|
|
0x0B: self.op_else,
|
|
0x0C: self.op_while,
|
|
0x0D: self.op_for,
|
|
0x0E: self.op_end,
|
|
0x0F: self.op_print
|
|
}
|
|
|
|
def op_add(self, args: List[int]) -> None:
|
|
"""Add two values"""
|
|
if len(args) >= 2:
|
|
result = args[0] + args[1]
|
|
self.registers[0] = result # Store result in r0
|
|
self.output.append(f"add {args[0]} + {args[1]} = {result}")
|
|
|
|
def op_subtract(self, args: List[int]) -> None:
|
|
"""Subtract two values"""
|
|
if len(args) >= 2:
|
|
result = args[0] - args[1]
|
|
self.registers[0] = result
|
|
self.output.append(f"subtract {args[0]} - {args[1]} = {result}")
|
|
|
|
def op_multiply(self, args: List[int]) -> None:
|
|
"""Multiply two values"""
|
|
if len(args) >= 2:
|
|
result = args[0] * args[1]
|
|
self.registers[0] = result
|
|
self.output.append(f"multiply {args[0]} * {args[1]} = {result}")
|
|
|
|
def op_divide(self, args: List[int]) -> None:
|
|
"""Divide two values"""
|
|
if len(args) >= 2 and args[1] != 0:
|
|
result = args[0] // args[1]
|
|
self.registers[0] = result
|
|
self.output.append(f"divide {args[0]} / {args[1]} = {result}")
|
|
|
|
def op_set(self, args: List[int]) -> None:
|
|
"""Set register value"""
|
|
if len(args) >= 2:
|
|
self.registers[args[0]] = args[1]
|
|
self.output.append(f"set r{args[0]} = {args[1]}")
|
|
|
|
def op_get(self, args: List[int]) -> None:
|
|
"""Get register value"""
|
|
if len(args) >= 1:
|
|
value = self.registers[args[0]]
|
|
self.registers[0] = value
|
|
self.output.append(f"get r{args[0]} = {value}")
|
|
|
|
def op_compare(self, args: List[int]) -> None:
|
|
"""Compare two values"""
|
|
if len(args) >= 2:
|
|
result = 1 if args[0] == args[1] else 0
|
|
self.registers[0] = result
|
|
self.output.append(f"compare {args[0]} == {args[1]} = {result}")
|
|
|
|
def op_jump(self, args: List[int]) -> None:
|
|
"""Jump to address"""
|
|
if len(args) >= 1:
|
|
self.pc = args[0]
|
|
self.output.append(f"jump to {args[0]}")
|
|
|
|
def op_call(self, args: List[int]) -> None:
|
|
"""Call subroutine"""
|
|
if len(args) >= 1:
|
|
self.stack.append(self.pc)
|
|
self.pc = args[0]
|
|
self.output.append(f"call {args[0]}")
|
|
|
|
def op_return(self, args: List[int]) -> None:
|
|
"""Return from subroutine"""
|
|
if self.stack:
|
|
self.pc = self.stack.pop()
|
|
self.output.append("return")
|
|
|
|
def op_if(self, args: List[int]) -> None:
|
|
"""Conditional jump"""
|
|
if len(args) >= 2:
|
|
if self.registers[0] != 0:
|
|
self.pc = args[0]
|
|
else:
|
|
self.pc = args[1]
|
|
self.output.append(f"if r0 != 0 jump to {args[0]} else {args[1]}")
|
|
|
|
def op_else(self, args: List[int]) -> None:
|
|
"""Else branch"""
|
|
self.output.append("else")
|
|
|
|
def op_while(self, args: List[int]) -> None:
|
|
"""While loop"""
|
|
self.output.append("while")
|
|
|
|
def op_for(self, args: List[int]) -> None:
|
|
"""For loop"""
|
|
self.output.append("for")
|
|
|
|
def op_end(self, args: List[int]) -> None:
|
|
"""End block"""
|
|
self.output.append("end")
|
|
|
|
def op_print(self, args: List[int]) -> None:
|
|
"""Print value"""
|
|
if len(args) >= 1:
|
|
value = args[0]
|
|
self.output.append(f"print {value}")
|
|
else:
|
|
value = self.registers[0]
|
|
self.output.append(f"print r0 = {value}")
|
|
|
|
def execute(self, bytecode: bytes) -> List[str]:
|
|
"""Execute GCL bytecode"""
|
|
self.pc = 0
|
|
self.running = True
|
|
self.output = []
|
|
|
|
while self.pc < len(bytecode) and self.running:
|
|
marker = bytecode[self.pc]
|
|
self.pc += 1
|
|
|
|
if marker == 0x01: # Operation
|
|
if self.pc < len(bytecode):
|
|
op_code = bytecode[self.pc]
|
|
self.pc += 1
|
|
|
|
# Collect arguments (simplified: assume next bytes are args)
|
|
args = []
|
|
while self.pc < len(bytecode) and bytecode[self.pc] < 0x10:
|
|
args.append(bytecode[self.pc])
|
|
self.pc += 1
|
|
|
|
if op_code in self.operations:
|
|
self.operations[op_code](args)
|
|
|
|
elif marker == 0x02: # Register
|
|
if self.pc < len(bytecode):
|
|
reg_code = bytecode[self.pc]
|
|
self.pc += 1
|
|
self.output.append(f"register r{reg_code}")
|
|
|
|
elif marker == 0x03: # Value
|
|
if self.pc < len(bytecode):
|
|
val_code = bytecode[self.pc]
|
|
self.pc += 1
|
|
self.output.append(f"value {val_code}")
|
|
|
|
elif marker == 0x04: # Literal
|
|
if self.pc + 3 < len(bytecode):
|
|
literal = bytecode[self.pc:self.pc+4]
|
|
self.pc += 4
|
|
try:
|
|
text = literal.decode('ascii').rstrip('\x00')
|
|
self.output.append(f"literal '{text}'")
|
|
except:
|
|
self.output.append(f"literal {literal.hex()}")
|
|
|
|
return self.output
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|
# Sentence as Computation Test
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
def test_sentence_as_computation():
|
|
"""Test that a sentence can be computation via GCL virtual machine"""
|
|
|
|
print("=" * 80)
|
|
print("SENTENCE AS COMPUTATION TEST")
|
|
print("=" * 80)
|
|
print()
|
|
|
|
# Test sentences
|
|
test_sentences = [
|
|
"add five to three",
|
|
"multiply seven by six",
|
|
"set r1 to ten",
|
|
"compare five with five",
|
|
"print r0"
|
|
]
|
|
|
|
encoder = SentenceEncoder()
|
|
vm = GCLVirtualMachine()
|
|
|
|
for sentence in test_sentences:
|
|
print(f"Sentence: \"{sentence}\"")
|
|
print("-" * 80)
|
|
|
|
# Encode sentence as GCL bytecode
|
|
bytecode = encoder.encode_sentence(sentence)
|
|
print(f"GCL Bytecode: {bytecode.hex()}")
|
|
print(f"Bytecode Length: {len(bytecode)} bytes")
|
|
|
|
# Execute bytecode
|
|
output = vm.execute(bytecode)
|
|
print(f"Execution Output:")
|
|
for line in output:
|
|
print(f" {line}")
|
|
|
|
print()
|
|
|
|
# Test computational result
|
|
print("=" * 80)
|
|
print("COMPUTATIONAL RESULT TEST")
|
|
print("=" * 80)
|
|
print()
|
|
|
|
# Sentence: "add five to three" should compute 8
|
|
sentence = "add five to three"
|
|
encoder = SentenceEncoder()
|
|
vm = GCLVirtualMachine()
|
|
|
|
bytecode = encoder.encode_sentence(sentence)
|
|
output = vm.execute(bytecode)
|
|
|
|
print(f"Sentence: \"{sentence}\"")
|
|
print(f"Expected Result: 8")
|
|
print(f"Actual Result: r0 = {vm.registers[0]}")
|
|
print(f"Match: {vm.registers[0] == 8}")
|
|
print()
|
|
|
|
# Test surface field measurement
|
|
print("=" * 80)
|
|
print("SURFACE FIELD MEASUREMENT")
|
|
print("=" * 80)
|
|
print()
|
|
|
|
surface = GCLSurface(
|
|
alphabet_size=26, # English alphabet
|
|
bits_per_symbol=5, # 5 bits per letter (log2(26) ≈ 4.7)
|
|
role_flags=0x01, # Has role
|
|
operation_flags=0xFF, # All operations available
|
|
closure_kind="complement" # Complement-closed
|
|
)
|
|
|
|
print(f"Surface Field: {surface.surface_field():.4f}")
|
|
print(f"Closure Field: {surface.closure_field():.4f}")
|
|
print(f"Motif Field: {surface.motif_field():.4f}")
|
|
print(f"Informaton Field: {surface.informaton_field():.4f}")
|
|
print()
|
|
|
|
# Test delta encoding
|
|
print("=" * 80)
|
|
print("DELTA ENCODING TEST")
|
|
print("=" * 80)
|
|
print()
|
|
|
|
sentence1 = "add five to three"
|
|
sentence2 = "add five to four" # Only one word changed
|
|
|
|
encoder = SentenceEncoder()
|
|
bytecode1 = encoder.encode_sentence(sentence1)
|
|
bytecode2 = encoder.encode_sentence(sentence2)
|
|
|
|
print(f"Sentence 1: \"{sentence1}\"")
|
|
print(f"Bytecode 1: {bytecode1.hex()}")
|
|
print()
|
|
print(f"Sentence 2: \"{sentence2}\"")
|
|
print(f"Bytecode 2: {bytecode2.hex()}")
|
|
print()
|
|
|
|
# Compute delta
|
|
delta = encoder.compute_delta(encoder.tokenize(sentence2), encoder.tokenize(sentence1))
|
|
print(f"Delta Has Changed: {delta.has_delta}")
|
|
print(f"Changed Fields: {delta.changed_fields}")
|
|
print()
|
|
|
|
# Conclusion
|
|
print("=" * 80)
|
|
print("CONCLUSION")
|
|
print("=" * 80)
|
|
print("""
|
|
The test demonstrates:
|
|
|
|
1. Sentence Encoding:
|
|
- "add five to three" encodes to GCL bytecode
|
|
- Bytecode is compact representation of sentence structure
|
|
- Delta encoding detects changes between sentences
|
|
|
|
2. Virtual Machine Execution:
|
|
- GCL bytecode executes on virtual machine
|
|
- Operations (add, multiply, set, compare) produce results
|
|
- "add five to three" correctly computes 8
|
|
|
|
3. Surface Field Measurement:
|
|
- Sentence carries structure (surface field > 0)
|
|
- Sentence preserves structure (closure field > 0)
|
|
- Sentence has executable affordances (motif field > 0)
|
|
- Sentence can enter manifold (informaton field > 0)
|
|
|
|
4. Computational Result:
|
|
- Sentence produces deterministic computational result
|
|
- Result matches expected value (8)
|
|
- Execution is reproducible
|
|
|
|
CONCLUSION:
|
|
A sentence IS computation when:
|
|
- Encoded as GCL primitives (delta, pattern, field operations)
|
|
- Executed by virtual machine (GCL interpreter)
|
|
- Produces deterministic computational result
|
|
|
|
The boundary between language and computation is porous. A sentence is dormant
|
|
computation without a virtual machine. The virtual machine provides the
|
|
execution context. The substrate determines what computations are possible.
|
|
|
|
This proves the claim: "even a sentence is computation if you are able to
|
|
create a virtual machine with it."
|
|
""")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
test_sentence_as_computation()
|