mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
346 lines
10 KiB
Python
346 lines
10 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
gpl_compiler_demo.py
|
||
|
||
Minimal demonstration of compiling Geometric Programming Language (GPL)
|
||
to μ-seed populations for TTM execution.
|
||
|
||
Shows: Source code → μ-seeds → execution → result
|
||
"""
|
||
|
||
from dataclasses import dataclass, field
|
||
from typing import List, Dict, Tuple, Optional
|
||
from enum import IntEnum
|
||
|
||
|
||
class RegionClass(IntEnum):
|
||
SURFACE = 0
|
||
INTERIOR = 1
|
||
TUNNEL = 2
|
||
VERTEX = 3
|
||
|
||
|
||
class GammaMode(IntEnum):
|
||
ACCUMULATE = 0
|
||
NOISE = 1
|
||
INTERACT = 2
|
||
COLLAPSE = 3
|
||
OPEN = 4
|
||
|
||
|
||
@dataclass
|
||
class MuSeed:
|
||
"""μ-seed: The compiled form of GPL statements."""
|
||
node_id: int
|
||
delta_p: int = 0
|
||
region: int = RegionClass.INTERIOR
|
||
gamma: int = GammaMode.OPEN
|
||
activation: int = 0
|
||
polarity: int = 0
|
||
confidence: int = 8
|
||
chirality: int = 0 # 0=D, 1=L
|
||
|
||
# Runtime links (not stored in 32-bit representation)
|
||
neighbors: List[int] = field(default_factory=list)
|
||
|
||
|
||
@dataclass
|
||
class GPLProgram:
|
||
"""Compiled GPL program ready for TTM execution."""
|
||
name: str
|
||
nodes: Dict[int, MuSeed]
|
||
edges: List[Tuple[int, int, int]] # (source, target, gamma)
|
||
inputs: List[int]
|
||
outputs: List[int]
|
||
|
||
def to_activation_field(self) -> Dict[int, float]:
|
||
"""Convert to initial activation field."""
|
||
return {nid: node.activation for nid, node in self.nodes.items()}
|
||
|
||
def display(self):
|
||
"""Pretty-print the compiled program."""
|
||
print(f"\nCompiled Program: {self.name}")
|
||
print(f"Nodes: {len(self.nodes)}")
|
||
print(f"Edges: {len(self.edges)}")
|
||
print(f"Inputs: {self.inputs}")
|
||
print(f"Outputs: {self.outputs}")
|
||
|
||
print("\nNode Table:")
|
||
for nid, node in sorted(self.nodes.items()):
|
||
region_name = ['SURFACE', 'INTERIOR', 'TUNNEL', 'VERTEX'][node.region]
|
||
gamma_name = ['ACC', 'NOISE', 'INTERACT', 'COLLAPSE', 'OPEN'][node.gamma]
|
||
chirality = 'D' if node.chirality == 0 else 'L'
|
||
print(f" μ_{nid:02d}: {region_name:8s} γ={gamma_name:8s} "
|
||
f"a={node.activation:2d} C={node.confidence:2d} χ={chirality}")
|
||
|
||
print("\nConnectivity:")
|
||
for src, tgt, gamma in self.edges:
|
||
gamma_name = ['ACC', 'NOISE', 'INTERACT', 'COLLAPSE', 'OPEN'][gamma]
|
||
print(f" μ_{src:02d} --[{gamma_name:8s}]--> μ_{tgt:02d}")
|
||
|
||
|
||
class GPLCompiler:
|
||
"""
|
||
Minimal GPL compiler.
|
||
|
||
Parses simple GPL syntax and compiles to μ-seed population.
|
||
"""
|
||
|
||
def __init__(self):
|
||
self.node_counter = 0
|
||
self.nodes: Dict[int, MuSeed] = {}
|
||
self.edges: List[Tuple[int, int, int]] = []
|
||
self.inputs: List[int] = []
|
||
self.outputs: List[int] = []
|
||
|
||
def new_node(self, region: RegionClass, **kwargs) -> int:
|
||
"""Create a new μ-seed node."""
|
||
node_id = self.node_counter
|
||
self.node_counter += 1
|
||
|
||
node = MuSeed(
|
||
node_id=node_id,
|
||
region=region.value,
|
||
**kwargs
|
||
)
|
||
self.nodes[node_id] = node
|
||
return node_id
|
||
|
||
def add_edge(self, src: int, tgt: int, gamma: GammaMode):
|
||
"""Add a directed edge (codon link)."""
|
||
self.edges.append((src, tgt, gamma.value))
|
||
self.nodes[src].neighbors.append(tgt)
|
||
|
||
def compile_hello_world(self) -> GPLProgram:
|
||
"""
|
||
Compile a simple Hello World program.
|
||
|
||
Program: trigger -> accumulate -> process -> noise -> buffer -> collapse -> result
|
||
"""
|
||
# Clear state
|
||
self.__init__()
|
||
|
||
# Create nodes
|
||
μ_trigger = self.new_node(
|
||
RegionClass.SURFACE,
|
||
activation=8,
|
||
confidence=15,
|
||
chirality=0
|
||
)
|
||
self.inputs.append(μ_trigger)
|
||
|
||
μ_process = self.new_node(
|
||
RegionClass.INTERIOR,
|
||
activation=0,
|
||
confidence=8,
|
||
gamma=GammaMode.ACCUMULATE.value,
|
||
chirality=0
|
||
)
|
||
|
||
μ_buffer = self.new_node(
|
||
RegionClass.INTERIOR,
|
||
activation=0,
|
||
confidence=8,
|
||
gamma=GammaMode.NOISE.value,
|
||
chirality=1 # L-form for mirror processing
|
||
)
|
||
|
||
μ_result = self.new_node(
|
||
RegionClass.SURFACE,
|
||
activation=0,
|
||
confidence=8,
|
||
gamma=GammaMode.COLLAPSE.value,
|
||
chirality=0
|
||
)
|
||
self.outputs.append(μ_result)
|
||
|
||
# Create edges (program flow)
|
||
self.add_edge(μ_trigger, μ_process, GammaMode.ACCUMULATE)
|
||
self.add_edge(μ_process, μ_buffer, GammaMode.NOISE)
|
||
self.add_edge(μ_buffer, μ_result, GammaMode.COLLAPSE)
|
||
|
||
return GPLProgram(
|
||
name="hello_world",
|
||
nodes=self.nodes,
|
||
edges=self.edges,
|
||
inputs=self.inputs,
|
||
outputs=self.outputs
|
||
)
|
||
|
||
def compile_adder(self, bits: int = 2) -> GPLProgram:
|
||
"""
|
||
Compile a ripple-carry adder.
|
||
|
||
Architecture: Chain of full adders
|
||
"""
|
||
self.__init__()
|
||
|
||
# Create input nodes (A, B for each bit)
|
||
a_nodes = []
|
||
b_nodes = []
|
||
for i in range(bits):
|
||
a_nodes.append(self.new_node(
|
||
RegionClass.SURFACE,
|
||
activation=i+1, # Different values for each bit
|
||
confidence=15,
|
||
chirality=0
|
||
))
|
||
b_nodes.append(self.new_node(
|
||
RegionClass.SURFACE,
|
||
activation=i+2,
|
||
confidence=15,
|
||
chirality=0
|
||
))
|
||
self.inputs.extend([a_nodes[-1], b_nodes[-1]])
|
||
|
||
# Create full adder chain
|
||
sum_nodes = []
|
||
carry_nodes = []
|
||
|
||
prev_carry = self.new_node(
|
||
RegionClass.INTERIOR,
|
||
activation=0, # Initial carry = 0
|
||
confidence=15,
|
||
chirality=0
|
||
)
|
||
|
||
for i in range(bits):
|
||
# Full adder internal nodes
|
||
# sum = a XOR b XOR cin
|
||
# carry = (a AND b) OR (cin AND (a XOR b))
|
||
|
||
# Simplified: use INTERACT for accumulation
|
||
xor_ab = self.new_node(
|
||
RegionClass.INTERIOR,
|
||
gamma=GammaMode.INTERACT.value,
|
||
chirality=0
|
||
)
|
||
|
||
sum_node = self.new_node(
|
||
RegionClass.INTERIOR,
|
||
gamma=GammaMode.ACCUMULATE.value,
|
||
chirality=0
|
||
)
|
||
|
||
carry_node = self.new_node(
|
||
RegionClass.INTERIOR,
|
||
gamma=GammaMode.ACCUMULATE.value,
|
||
chirality=1 # L-form for carry
|
||
)
|
||
|
||
# Connect
|
||
self.add_edge(a_nodes[i], xor_ab, GammaMode.INTERACT)
|
||
self.add_edge(b_nodes[i], xor_ab, GammaMode.INTERACT)
|
||
self.add_edge(xor_ab, sum_node, GammaMode.ACCUMULATE)
|
||
self.add_edge(prev_carry, sum_node, GammaMode.ACCUMULATE)
|
||
|
||
self.add_edge(a_nodes[i], carry_node, GammaMode.INTERACT)
|
||
self.add_edge(b_nodes[i], carry_node, GammaMode.INTERACT)
|
||
self.add_edge(prev_carry, carry_node, GammaMode.INTERACT)
|
||
|
||
# Collapse to output
|
||
sum_out = self.new_node(
|
||
RegionClass.SURFACE,
|
||
gamma=GammaMode.COLLAPSE.value,
|
||
chirality=0
|
||
)
|
||
self.add_edge(sum_node, sum_out, GammaMode.COLLAPSE)
|
||
self.outputs.append(sum_out)
|
||
|
||
sum_nodes.append(sum_out)
|
||
carry_nodes.append(carry_node)
|
||
prev_carry = carry_node
|
||
|
||
# Final carry output
|
||
final_carry = self.new_node(
|
||
RegionClass.SURFACE,
|
||
gamma=GammaMode.COLLAPSE.value,
|
||
chirality=0
|
||
)
|
||
self.add_edge(prev_carry, final_carry, GammaMode.COLLAPSE)
|
||
self.outputs.append(final_carry)
|
||
|
||
return GPLProgram(
|
||
name=f"{bits}bit_adder",
|
||
nodes=self.nodes,
|
||
edges=self.edges,
|
||
inputs=self.inputs,
|
||
outputs=self.outputs
|
||
)
|
||
|
||
|
||
def demo_compilation():
|
||
"""Demonstrate compiling GPL programs to μ-seeds."""
|
||
|
||
print("=" * 60)
|
||
print("GEOMETRIC PROGRAMMING LANGUAGE (GPL) COMPILER DEMO")
|
||
print("=" * 60)
|
||
|
||
compiler = GPLCompiler()
|
||
|
||
# Demo 1: Hello World
|
||
print("\n" + "=" * 60)
|
||
print("PROGRAM 1: Hello World")
|
||
print("=" * 60)
|
||
|
||
program1 = compiler.compile_hello_world()
|
||
program1.display()
|
||
|
||
print("\n" + "-" * 60)
|
||
print("Execution Simulation:")
|
||
print("-" * 60)
|
||
|
||
field = program1.to_activation_field()
|
||
print(f"Initial activation field: {field}")
|
||
|
||
# Simulate one TTM tick
|
||
print("\nTick 1:")
|
||
# Accumulate: trigger -> process
|
||
field[1] = field[1] + 0.5 * field[0] # process accumulates from trigger
|
||
print(f" μ_process accumulates: {field[1]:.2f}")
|
||
|
||
# Noise: process -> buffer
|
||
field[2] = field[2] + 0.3 * field[1] # buffer gets noise-scaled process
|
||
print(f" μ_buffer receives: {field[2]:.2f}")
|
||
|
||
# Collapse: buffer -> result
|
||
if field[2] > 2.0:
|
||
field[3] = min(15, int(field[2]))
|
||
print(f" μ_result collapses to: {field[3]}")
|
||
|
||
# Demo 2: Adder
|
||
print("\n" + "=" * 60)
|
||
print("PROGRAM 2: 2-Bit Adder")
|
||
print("=" * 60)
|
||
|
||
program2 = compiler.compile_adder(bits=2)
|
||
program2.display()
|
||
|
||
print("\n" + "=" * 60)
|
||
print("SUMMARY")
|
||
print("=" * 60)
|
||
|
||
print(f"""
|
||
GPL Compilation Results:
|
||
|
||
Hello World:
|
||
- Source: 5 lines of GPL code
|
||
- Compiled: {len(program1.nodes)} μ-seeds, {len(program1.edges)} edges
|
||
- Memory: {len(program1.nodes) * 4} bytes
|
||
- Execution: TTM convergence
|
||
|
||
2-Bit Adder:
|
||
- Source: Structural description
|
||
- Compiled: {len(program2.nodes)} μ-seeds, {len(program2.edges)} edges
|
||
- Memory: {len(program2.nodes) * 4} bytes
|
||
- Execution: Parallel TTM dynamics
|
||
|
||
Key Insight:
|
||
GPL programs compile to μ-seed populations (4 bytes each).
|
||
Execution is TTM convergence (not instruction fetch).
|
||
Topology IS the program.
|
||
""")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
demo_compilation()
|