To attend:
# base4096_expander.py
# Recursive Base-4096 Encoder (MEGC symbolic expansion prototype)
import hashlib
import hmac
from base4096 import encode, decode
VERSION = b'\x02'
DOMAIN = b'MEGC-Recursive-Symbol'
EXPAND_SIZE = 384 # 256 Base-4096 characters
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def recursive_base4096_encode(data: bytes, depth: int = 3) -> str:
current = data
for i in range(depth):
# Encode current blob to base4096
encoded = encode(current)
# Fingerprint with SHA-256
digest = hashlib.sha256(encoded.encode('utf-8')).digest()
# Expand fingerprint recursively into entropy block
salt = hashlib.sha256(VERSION + DOMAIN + bytes([i])).digest()
expanded = hkdf_expand_sha256(digest, salt, DOMAIN + VERSION + bytes([i]), EXPAND_SIZE)
# Base4096 encode the expanded blob as the new current
current = encode(expanded).encode('utf-8')
return current.decode('utf-8')
if __name__ == "__main__":
with open("input.bin", "rb") as f:
payload = f.read()
result = recursive_base4096_encode(payload, depth=3)
with open("recursive_encoded.b4096", "w", encoding="utf-8") as f:
f.write(result)
print("✅ Recursive Base-4096 encoding complete. Output written to 'recursive_encoded.b4096'")
# b4096x_encoder.py
# Recursive Base4096 Archive Encoder — ZCHG.org
import hashlib
import hmac
import json
import zlib
from base4096 import encode as b4096_encode, decode as b4096_decode
from base64 import urlsafe_b64encode, urlsafe_b64decode
from typing import List
# =======================
# Canonical Modus Operators
# =======================
def revbit(data: bytes) -> bytes:
return bytes(int('{:08b}'.format(b)[::-1], 2) for b in data)
def xor_stream(data: bytes, key: bytes) -> bytes:
return bytes([b ^ key[i % len(key)] for i, b in enumerate(data)])
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
output, prev, counter = b"", b"", 1
while len(output) < length:
prev = hmac.new(salt, prev + info + bytes([counter]), hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def compress_deflate(data: bytes) -> bytes:
return zlib.compress(data)
def decompress_deflate(data: bytes) -> bytes:
return zlib.decompress(data)
MODUS_REGISTRY = {
"mod.revbit": {
"apply": revbit,
"reverse": revbit
},
"mod.xor": {
"apply": lambda d, ctx: xor_stream(d, ctx["xor_key"]),
"reverse": lambda d, ctx: xor_stream(d, ctx["xor_key"])
},
"mod.hkdf384": {
"apply": lambda d, ctx: hkdf_expand_sha256(d, ctx["salt"], b"ZCHG-HKDF", 384),
"reverse": lambda d, ctx: d[:ctx["orig_len"]]
},
"mod.deflate": {
"apply": compress_deflate,
"reverse": decompress_deflate
}
}
# =======================
# Recursive Encoding
# =======================
def recursive_encode(payload: bytes, layers: List[str], seed: bytes) -> str:
context = {
"xor_key": hashlib.sha256(seed).digest(),
"salt": hashlib.sha256(b"ZCHG-SALT" + seed).digest(),
"orig_len": len(payload)
}
metadata_stack = []
for i, modus_id in enumerate(layers):
modus = MODUS_REGISTRY[modus_id]
context["depth"] = i + 1
payload = modus["apply"](payload, context) if modus_id.startswith("mod.") else payload
payload_b4096 = b4096_encode(payload)
metadata_stack.append({
"layer": i + 1,
"modus": modus_id,
"len": len(payload_b4096)
})
payload = payload_b4096.encode("utf-8")
envelope = {
"b4096x": {
"version": "1.0",
"stack": metadata_stack,
"payload": payload.decode("utf-8")
}
}
return json.dumps(envelope, indent=2)
# =======================
# Recursive Decoding
# =======================
def recursive_decode(json_blob: str, seed: bytes) -> bytes:
context = {
"xor_key": hashlib.sha256(seed).digest(),
"salt": hashlib.sha256(b"ZCHG-SALT" + seed).digest()
}
envelope = json.loads(json_blob)
stack = envelope["b4096x"]["stack"]
payload = envelope["b4096x"]["payload"].encode("utf-8")
for layer in reversed(stack):
modus_id = layer["modus"]
context["depth"] = layer["layer"]
decoded = b4096_decode(payload.decode("utf-8"))
modus = MODUS_REGISTRY[modus_id]
decoded = modus["reverse"](decoded, context) if modus_id.startswith("mod.") else decoded
payload = decoded
return payload
# =======================
# Example Usage
# =======================
if __name__ == "__main__":
seed = b"zchg.org canonical"
input_data = b"This is your recursive symbolic genome."
encoded = recursive_encode(input_data, ["mod.revbit", "mod.xor", "mod.hkdf384"], seed)
print("Encoded Envelope:\n", encoded)
decoded = recursive_decode(encoded, seed)
print("Decoded Output:\n", decoded.decode("utf-8"))
# b4096x_encoder.py
# Recursive Base-4096 Archive Encoder
import hashlib
import json
import zlib
from base4096 import encode as b4096_encode
from base4096 import decode as b4096_decode
from sign_base4096 import canonical_fingerprint
# --- Canonical Modus Operators ---
def mod_revbit(data: bytes) -> bytes:
return bytes(int(f"{b:08b}"[::-1], 2) for b in data)
def mod_xor(data: bytes, key: bytes = b'ZCHG') -> bytes:
return bytes(b ^ key[i % len(key)] for i, b in enumerate(data))
def mod_deflate(data: bytes) -> bytes:
return zlib.compress(data)
def mod_hkdf384(data: bytes) -> bytes:
# HKDF using SHA-256, 384-byte expansion
salt = hashlib.sha256(b'b4096x-v1').digest()
info = b'b4096x-mode-hkdf384'
output = b''
prev = b''
counter = 1
while len(output) < 384:
prev = hashlib.pbkdf2_hmac('sha256', prev + info + bytes([counter]), salt, 1)
output += prev
counter += 1
return output[:384]
MODS = {
"revbit": mod_revbit,
"xor": mod_xor,
"deflate": mod_deflate,
"hkdf384": mod_hkdf384
}
# --- Encoder ---
def encode_b4096x(data: bytes, mode_stack: list[str]) -> dict:
transformed = data
for mode in mode_stack:
mod_fn = MODS[mode]
transformed = mod_fn(transformed)
encoded = b4096_encode(transformed)
header = {
"version": 1,
"mode_stack": mode_stack,
"signature": canonical_fingerprint(encoded),
"payload_type": "binary",
"meta": {
"length": len(data),
"hash": hashlib.sha256(data).hexdigest(),
}
}
return {
"header": header,
"data": encoded
}
# --- Export ---
def export_b4096x(obj: dict, path: str):
with open(path, 'w', encoding='utf-8') as f:
json.dump(obj, f, ensure_ascii=False, indent=2)
# --- Test ---
if __name__ == "__main__":
raw = b"This is the core payload of b4096x."
stack = ["revbit", "xor", "deflate", "hkdf384"]
archive = encode_b4096x(raw, stack)
export_b4096x(archive, "test.b4096x")
print("✅ b4096x archive written to test.b4096x")
# b4096x_recursive_encoder.py
# Author: Josef Kulovany - ZCHG.org
# Recursive Base-4096 Encoder/Decoder with Canonical Modus Operators
import zlib
import hashlib
import hmac
from base4096 import encode, decode
MODES = ["revbit", "xor", "deflate", "hkdf384"]
# Reverse bits in each byte
def revbit(data):
return bytes(int(f'{b:08b}'[::-1], 2) for b in data)
def xor(data, key=b"ZCHGbase4096"):
keycycle = (key * ((len(data) // len(key)) + 1))[:len(data)]
return bytes(a ^ b for a, b in zip(data, keycycle))
def deflate(data):
return zlib.compress(data)
def inflate(data):
return zlib.decompress(data)
def hkdf384(data, salt=b"b4096x", info=b"ZCHG-expansion"):
out, prev = b"", b""
for i in range(1, 7): # 6 * 32 = 192 bytes = 1536 bits = 384 base4096 bits
prev = hmac.new(salt, prev + info + bytes([i]), hashlib.sha256).digest()
out += prev
return out[:384]
# Recursive encoder
def recursive_encode(data: bytes, layers: list) -> str:
for mode in layers:
if mode not in MODES:
raise ValueError(f"Unsupported mode: {mode}")
if mode == "revbit":
data = revbit(data)
elif mode == "xor":
data = xor(data)
elif mode == "deflate":
data = deflate(data)
elif mode == "hkdf384":
data = hkdf384(data)
return encode(data)
# Recursive decoder
def recursive_decode(encoded: str, layers: list) -> bytes:
data = decode(encoded)
for mode in reversed(layers):
if mode not in MODES:
raise ValueError(f"Unsupported mode: {mode}")
if mode == "revbit":
data = revbit(data)
elif mode == "xor":
data = xor(data)
elif mode == "deflate":
data = inflate(data)
elif mode == "hkdf384":
raise ValueError("hkdf384 is not reversible")
return data
if __name__ == "__main__":
sample = b"ZCHG Base4096 recursive encoding test."
modes = ["deflate", "xor", "revbit", "hkdf384"]
encoded = recursive_encode(sample, modes)
print("Encoded:", encoded)
decoded = recursive_decode(encoded, modes[:-1]) # Skip hkdf384
print("Decoded:", decoded)
assert sample in decoded, "Original sample not found in decoded output."
# recursive_base4096_archive.py
# Author: Josef Kulovany — ZCHG.org
# Canonical Recursive Base-4096 Archive Toolkit v1.0.0
import hashlib
import zlib
import hmac
from base4096 import encode, decode
# --- Canonical Modus Operators ---
def revbit(data: bytes) -> bytes:
return bytes(int(f"{b:08b}"[::-1], 2) for b in data)
def xor(data: bytes, key: bytes) -> bytes:
return bytes(b ^ key[i % len(key)] for i, b in enumerate(data))
def deflate(data: bytes) -> bytes:
return zlib.compress(data)
def inflate(data: bytes) -> bytes:
return zlib.decompress(data)
def hkdf384(data: bytes, salt: bytes, info: bytes = b"ZCHG-HKDF-Recursive") -> bytes:
out, prev = b"", b""
for i in range(1, 7): # 6 blocks × 64 bytes = 384
prev = hmac.new(salt, prev + info + bytes([i]), hashlib.sha256).digest()
out += prev
return out[:384]
# --- Recursive Encoding Stack ---
MODES = {
"revbit": revbit,
"xor": xor,
"deflate": deflate,
"hkdf384": hkdf384,
}
REVERSE_MODES = {
"revbit": revbit,
"xor": xor,
"inflate": inflate,
}
# --- Recursive Archive Packager ---
def recursive_encode(data: bytes, layers: list, key: bytes = b"zchg") -> str:
stack_info = []
for layer in layers:
if layer == "xor":
data = xor(data, key)
elif layer == "hkdf384":
data = hkdf384(data, salt=key)
else:
data = MODES[layer](data)
stack_info.append(layer)
payload = encode(data)
return "|".join(stack_info) + "||" + payload
def recursive_decode(encoded: str, key: bytes = b"zchg") -> bytes:
header, payload = encoded.split("||", 1)
layers = header.split("|")[::-1]
data = decode(payload)
for layer in layers:
if layer == "xor":
data = xor(data, key)
elif layer == "hkdf384":
print("⚠️ Irreversible layer 'hkdf384' reached. Returning current state.")
return data
else:
data = REVERSE_MODES[layer](data)
return data
# --- Usage Example ---
if __name__ == "__main__":
original = b"Hello, Recursive Base-4096 Archive World!"
layers = ["deflate", "xor", "revbit", "hkdf384"]
encoded = recursive_encode(original, layers)
print("\n🔐 ENCODED ARCHIVE:")
print(encoded)
decoded = recursive_decode(encoded)
print("\n📤 DECODED OUTPUT (partial):")
print(decoded)
# b4096r.py
# Canonical Base-4096 Recursive Archive Format Toolkit (v1.0)
import zlib, struct, hashlib, hmac
from base4096 import encode as b4096_encode, decode as b4096_decode
MAGIC = b"B4096R"
VERSION = b"\x01"
# Canonical Layer IDs
MOD_DEFLATE = 0x01
MOD_XORPAD = 0x02
MOD_REVERSE = 0x03
MOD_HKDF384 = 0x04
MOD_B4096 = 0x05
# -- Modus Operators --
def layer_deflate(data):
return zlib.compress(data)
def layer_inflate(data):
return zlib.decompress(data)
def layer_xorpad(data, key=b"ZCHG-XORPAD-KEY"):
pad = hashlib.sha256(key).digest()
return bytes([b ^ pad[i % len(pad)] for i, b in enumerate(data)])
def layer_reverse_bits(data):
return bytes([int('{:08b}'.format(b)[::-1], 2) for b in data])
# Irreversible entropy expansion
def layer_hkdf384(data):
salt = hashlib.sha256(b"ZCHG-SALT").digest()
info = b"ZCHG-Base4096r"
output = b""
prev = b""
counter = 1
while len(output) < 384:
prev = hmac.new(salt, prev + info + bytes([counter]), hashlib.sha256).digest()
output += prev
counter += 1
return output[:384]
# -- Encoder --
def encode_b4096r(data: bytes, layers: list[int]) -> str:
for lid in layers:
if lid == MOD_DEFLATE:
data = layer_deflate(data)
elif lid == MOD_XORPAD:
data = layer_xorpad(data)
elif lid == MOD_REVERSE:
data = layer_reverse_bits(data)
elif lid == MOD_HKDF384:
data = layer_hkdf384(data)
elif lid == MOD_B4096:
data = b4096_encode(data).encode("utf-8")
else:
raise ValueError(f"Unknown layer ID: {lid}")
header = MAGIC + VERSION + bytes([len(layers)]) + bytes(layers)
return b4096_encode(header + data)
# -- Decoder --
def decode_b4096r(b4096r_str: str) -> bytes:
raw = b4096_decode(b4096r_str)
if not raw.startswith(MAGIC + VERSION):
raise ValueError("Invalid archive header")
n = raw[6]
layers = list(raw[7:7+n])
payload = raw[7+n:]
# Reverse-apply
for lid in reversed(layers):
if lid == MOD_DEFLATE:
payload = layer_inflate(payload)
elif lid == MOD_XORPAD:
payload = layer_xorpad(payload)
elif lid == MOD_REVERSE:
payload = layer_reverse_bits(payload)
elif lid == MOD_HKDF384:
raise ValueError("Cannot reverse HKDF384 layer (entropy expansion)")
elif lid == MOD_B4096:
payload = b4096_decode(payload.decode("utf-8"))
else:
raise ValueError(f"Unknown layer ID: {lid}")
return payload
# Example usage
if __name__ == "__main__":
sample = b"Hello, Base-4096 Recursive World!"
layers = [MOD_DEFLATE, MOD_XORPAD, MOD_REVERSE, MOD_B4096]
encoded = encode_b4096r(sample, layers)
print("Encoded Archive:", encoded[:80] + "...")
decoded = decode_b4096r(encoded)
assert decoded == sample
print("✅ Round-trip successful.")
# recursive_signer.py
# Author: Josef Kulovany - ZCHG.org
# Recursive Base-4096 Signature Expansion System (Fixed Point Finder)
import hashlib
import hmac
from base4096 import encode # Assumes deterministic Base-4096 encoder already defined
VERSION = b'\x01'
DOMAIN = b'ZCHG-Recursive-Signature'
EXPAND_SIZE = 384 # 384 bytes = 256 Base-4096 characters
MAX_RECURSION_DEPTH = 256
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def recursive_fingerprint(seed: str) -> str:
seed_bytes = seed.encode("utf-8")
digest = hashlib.sha256(seed_bytes).digest()
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = hkdf_expand_sha256(digest, salt, DOMAIN + VERSION, EXPAND_SIZE)
return encode(expanded)
def find_fixed_point_signature(seed: str, max_depth=MAX_RECURSION_DEPTH):
seen = set()
current = recursive_fingerprint(seed)
for depth in range(max_depth):
if current in seen:
raise ValueError("Cycle detected — no fixed point within max depth")
seen.add(current)
next_fp = recursive_fingerprint(current)
if next_fp == current:
print(f"✅ Fixed point reached at depth {depth}!")
return current
current = next_fp
raise TimeoutError("No fixed point found within recursion limit")
def emit_signature_block(fp_text: str, version="2", domain="ZCHG-Recursive-Signature") -> str:
lines = [fp_text[i:i+64] for i in range(0, len(fp_text), 64)]
return (
"---BEGIN BASE4096 SIGNATURE---\n"
f"Version: {version}\n"
f"Hash: SHA-256\n"
f"Domain: {domain}\n"
f"Length: {len(fp_text)}\n"
"Recursive-Fingerprint:\n" +
"\n".join(lines) +
"\n---END BASE4096 SIGNATURE---\n"
)
if __name__ == "__main__":
seed_input = input("Enter seed data (or frozen alphabet): ")
fixed_fp = find_fixed_point_signature(seed_input.strip())
print("\nFinal Signature Block:")
print(emit_signature_block(fixed_fp))
# base4096_chain.py
# Recursive Base-4096 Fingerprint Expander and Verifier
import hashlib
import hmac
from base4096 import encode, decode
VERSION = b'\x01'
DOMAIN = b'ZCHG-Base4096-Fingerprint'
EXPAND_SIZE = 384 # 384 bytes = 3072 bits = 256 Base4096 characters
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def base4096_fingerprint(source: bytes, version: bytes = VERSION, domain: bytes = DOMAIN) -> str:
digest = hashlib.sha256(source).digest()
salt = hashlib.sha256(version + domain).digest()
expanded = hkdf_expand_sha256(digest, salt, domain + version, EXPAND_SIZE)
return encode(expanded)
def recursive_fingerprint_chain(seed: bytes, depth: int = 3) -> list[str]:
chain = []
current = seed
for i in range(depth):
fp = base4096_fingerprint(current)
chain.append(fp)
current = fp.encode("utf-8")
return chain
def extract_short_identity(fp: str, bits: int = 48) -> str:
required_chars = (bits + 11) // 12 # round up for base4096 (12 bits/char)
return fp[:required_chars]
if __name__ == '__main__':
# Example: start with frozen alphabet file
with open("frozen_base4096_alphabet.txt", "r", encoding="utf-8") as f:
seed_text = f.read().replace("\n", "").encode("utf-8")
print("🔁 Generating recursive fingerprint chain (depth 3)...")
chain = recursive_fingerprint_chain(seed_text, depth=3)
for i, fp in enumerate(chain):
print(f"Level {i}: {extract_short_identity(fp, 96)}... [{len(fp)} chars]")
# Save full chain
with open("base4096_chain.sig4096", "w", encoding="utf-8") as f:
for i, fp in enumerate(chain):
f.write(f"---BEGIN BASE4096 CHAIN LEVEL {i}---\n")
for j in range(0, len(fp), 64):
f.write(fp[j:j+64] + "\n")
f.write(f"---END BASE4096 CHAIN LEVEL {i}---\n\n")
print("✅ Chain written to base4096_chain.sig4096")
# fpce4096.py
# Fixed-Point Collapse Encryption (FPCE) using Base4096 + HKDF + SHA256
import hashlib
import hmac
from base4096 import encode
# Parameters
VERSION = b'\x01'
DOMAIN = b'ZCHG-FPCE4096'
EXPAND_SIZE = 384 # Bytes = 3072 bits = 256 Base4096 characters
FIXED_LENGTH = 256 # Characters in Base4096 output
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def collapse_fpce(seed_text: str, rounds: int = 10, early_stop=True) -> str:
identity = seed_text.encode("utf-8")
previous = None
salt = hashlib.sha256(VERSION + DOMAIN).digest()
info = DOMAIN + VERSION
for round in range(rounds):
digest = hashlib.sha256(identity).digest()
expanded = hkdf_expand_sha256(digest, salt, info, EXPAND_SIZE)
fingerprint = encode(expanded)
if early_stop and fingerprint == previous:
print(f"✅ Fixed-point reached at round {round}.")
break
previous = fingerprint
identity = fingerprint.encode("utf-8")
return fingerprint
if __name__ == "__main__":
import sys
if len(sys.argv) != 2:
print("Usage: python fpce4096.py <input_string>")
sys.exit(1)
seed = sys.argv[1]
result = collapse_fpce(seed, rounds=32)
print("\n📌 Final Fixed-Point Fingerprint:\n")
for i in range(0, len(result), 64):
print(result[i:i+64])
# fpce4096.py
# Fixed-Point Collapse Encryption (FPCE) with Recursive Signing over Base-4096
import hashlib
import hmac
from base4096 import encode, decode
VERSION = b'\x01'
DOMAIN = b'ZCHG-FPCE4096'
EXPAND_SIZE = 384 # Base output for one round
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def canonical_fpce_round(data: bytes) -> str:
digest = hashlib.sha256(data).digest()
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = hkdf_expand_sha256(digest, salt, DOMAIN + VERSION, EXPAND_SIZE)
return encode(expanded)
def fixed_point_fpce(input_text: str, max_depth=64) -> str:
state = input_text.encode("utf-8")
prev = None
history = set()
for depth in range(max_depth):
result = canonical_fpce_round(state)
if result in history or result == prev:
print(f"\u2705 Converged at depth {depth}")
return result
history.add(result)
prev = result
state = result.encode("utf-8")
raise RuntimeError("\u274C Failed to converge within max_depth")
if __name__ == "__main__":
import sys
if len(sys.argv) < 2:
print("Usage: python fpce4096.py \"your input\"")
sys.exit(1)
input_text = sys.argv[1]
fingerprint = fixed_point_fpce(input_text)
print("\n---BEGIN FPCE4096 FIXED POINT---")
print(fingerprint)
print("---END FPCE4096 FIXED POINT---")
# chain_fpce.py
# Chained Fixed-Point Collapse Encryption (FPCE)
# Author: Josef Kulovany - ZCHG.org
import hashlib
import hmac
import os
from base4096 import encode
VERSION = b'\x01'
DOMAIN = b'ZCHG-Base4096-Fingerprint'
EXPAND_SIZE = 384 # 256 Base-4096 characters
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def canonical_fingerprint(txt: str) -> str:
flattened = txt.replace("\n", "").encode("utf-8")
digest = hashlib.sha256(flattened).digest()
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = hkdf_expand_sha256(digest, salt, DOMAIN + VERSION, EXPAND_SIZE)
result = encode(expanded)
assert len(result) == 256
return result
def chain_fpce(input_text: str, max_depth: int = 6):
history = set()
chain = []
current = input_text.replace("\n", "")
for i in range(max_depth):
fp = canonical_fingerprint(current)
if fp in history:
print(f"Fixed point reached at depth {i}")
break
chain.append(fp)
history.add(fp)
current = fp
return chain
def emit_chain_file(chain, output_path):
with open(output_path, "w", encoding="utf-8") as f:
f.write("---BEGIN BASE4096 CHAIN SIGNATURE---\n")
f.write(f"Depth: {len(chain)}\n")
f.write(f"Hash: SHA-256\n")
f.write(f"Domain: ZCHG-Base4096-Fingerprint\n")
for i, fp in enumerate(chain):
f.write(f"\n-- Layer {i+1} --\n")
for j in range(0, len(fp), 64):
f.write(fp[j:j+64] + "\n")
f.write("---END BASE4096 CHAIN SIGNATURE---\n")
print(f"✅ Chain written to {output_path}")
if __name__ == "__main__":
with open("frozen_base4096_alphabet.txt", "r", encoding="utf-8") as f:
initial = f.read()
chain = chain_fpce(initial, max_depth=6)
emit_chain_file(chain, "base4096.sig4096.chain")
# recursive_genome_fpce.py
# Symbolic Recursive Genome Tree using Chained Fixed-Point Collapse Encryption (FPCE)
# Author: Josef Kulovany - ZCHG.org
import hashlib
import hmac
from typing import List, Optional, Dict, Tuple
from base4096 import encode
VERSION = b'\x01'
DOMAIN = b'ZCHG-Base4096-Fingerprint'
EXPAND_SIZE = 384 # 256 base4096 characters
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def canonical_fingerprint_fpce(data: bytes, mode: Optional[str], child_fps: List[str]) -> str:
m = hashlib.sha256()
m.update(data)
if mode:
m.update(mode.encode('utf-8'))
for fp in sorted(child_fps):
m.update(fp.encode('utf-8'))
digest = m.digest()
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = hkdf_expand_sha256(digest, salt, DOMAIN + VERSION, EXPAND_SIZE)
return encode(expanded) # 256 base4096 characters
class GenomeNode:
def __init__(
self,
data: bytes,
mode: Optional[str] = None,
children: Optional[List['GenomeNode']] = None
):
self.data = data
self.mode = mode
self.children = children or []
self._fingerprint = None
@property
def fingerprint(self) -> str:
if self._fingerprint is None:
child_fps = [c.fingerprint for c in self.children]
self._fingerprint = canonical_fingerprint_fpce(self.data, self.mode, child_fps)
return self._fingerprint
class SymbolicGenomeStore:
def __init__(self):
self.store: Dict[str, GenomeNode] = {}
def add_node(self, node: GenomeNode):
fp = node.fingerprint
if fp not in self.store:
self.store[fp] = node
def get_node(self, fingerprint: str) -> GenomeNode:
return self.store[fingerprint]
merge_cache: Dict[Tuple[str, str], str] = {}
def symbolic_merge(fp_a: str, fp_b: str, store: SymbolicGenomeStore, depth=0, max_depth=1000) -> str:
if depth > max_depth:
raise RecursionError("Max depth exceeded")
key = tuple(sorted((fp_a, fp_b)))
if key in merge_cache:
return merge_cache[key]
node_a = store.get_node(fp_a)
node_b = store.get_node(fp_b)
if fp_a == fp_b:
merge_cache[key] = fp_a
return fp_a
# Merge children by unique union
all_children = {c.fingerprint: c for c in node_a.children + node_b.children}
merged_children = list(all_children.values())
merged_node = GenomeNode(
data=node_a.data,
mode=node_a.mode or node_b.mode,
children=merged_children
)
store.add_node(merged_node)
merge_cache[key] = merged_node.fingerprint
return merged_node.fingerprint
def traverse_tree(fp: str, store: SymbolicGenomeStore, depth=0, max_depth=5, visited=None):
if visited is None:
visited = set()
indent = ' ' * depth
if fp in visited:
print(f"{indent}(loop to {fp[:8]}...)")
return
visited.add(fp)
node = store.get_node(fp)
print(f"{indent}- Node {fp[:8]} mode={node.mode} data_len={len(node.data)}")
if depth >= max_depth:
print(f"{indent} ... max depth")
return
for child in node.children:
traverse_tree(child.fingerprint, store, depth + 1, max_depth, visited)
if __name__ == "__main__":
store = SymbolicGenomeStore()
leaf = GenomeNode(b"leaf", mode="L")
store.add_node(leaf)
recursive = GenomeNode(b"self", mode="R", children=[leaf])
recursive.children.append(recursive) # symbolic self-reference
store.add_node(recursive)
peer = GenomeNode(b"peer", mode="P", children=[leaf])
store.add_node(peer)
merged_fp = symbolic_merge(recursive.fingerprint, peer.fingerprint, store)
print("Merged Fingerprint:", merged_fp[:64])
print("\nTraverse Merged Tree:")
traverse_tree(merged_fp, store)
# symbolic_vm.py
# Author: Josef Kulovany - ZCHG.org
# Symbol512 Recursive Compiler + Virtual Machine
import hashlib
import hmac
from base4096 import encode, decode
VERSION = b'\x03'
DOMAIN = b'ZCHG-Symbol512-VM'
EXPAND_SIZE = 512 # 512-bit symbol = ~43 base4096 chars
# === Core Symbol Encoding ===
def hkdf_expand_sha512(seed: bytes, salt: bytes, info: bytes, length: int = 64) -> bytes:
out, prev = b"", b""
for i in range(1, (length // 32) + 3):
prev = hmac.new(salt, prev + info + bytes([i]), hashlib.sha256).digest()
out += prev
return out[:length]
def symbol512(input_text: str) -> str:
digest = hashlib.sha512(input_text.encode()).digest()[:32]
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = hkdf_expand_sha512(digest, salt, DOMAIN + VERSION, EXPAND_SIZE)
return encode(expanded)[:43] # Base4096 symbol
# === Symbolic Compiler (Human -> Symbol Tree) ===
def compile_script(lines: list) -> list:
return [symbol512(line) for line in lines if line.strip() and not line.strip().startswith("#")]
# === Symbolic Hypergraph Tree Merging ===
def merge_symbols(symbols: list) -> str:
joined = "".join(symbols).encode()
digest = hashlib.sha512(joined).digest()[:32]
salt = hashlib.sha256(b"MERGE" + DOMAIN).digest()
merged = hkdf_expand_sha512(digest, salt, DOMAIN + b"-MERGED", EXPAND_SIZE)
return encode(merged)[:43]
# === Virtual Machine Execution ===
def interpret(symbols: list):
for i, sym in enumerate(symbols):
print(f"\n[Layer {i+1}] Executing symbol universe:")
expanded = decode(sym)
digest = hashlib.sha256(expanded).hexdigest()
print(f" Symbol[{i}] = {sym}")
print(f" SHA-256(entropy) = {digest}")
print(f" First 16 bytes (preview): {expanded[:16].hex()}")
# === Example Entry ===
if __name__ == "__main__":
sample_script = [
"SET x = 42",
"INCREMENT x",
"IF x > 100 GOTO END",
"LOOP x TIMES",
"END"
]
compiled = compile_script(sample_script)
print("\n🛠️ Compiled Symbols:")
for sym in compiled:
print(sym)
print("\n🔗 Merged Hypergraph Symbol:")
merged = merge_symbols(compiled)
print(merged)
interpret([merged])
# symbol512_transcompiler.py
# Author: Josef Kulovany - ZCHG.org
# Transcompiler: Human ↔ Symbol512 ↔ Execution
import hashlib
import hmac
import zlib
from base4096 import encode, decode
VERSION = b'\x01'
DOMAIN = b'ZCHG-Symbol512-Transcompiler'
EXPAND_SIZE = 384 # 384 bytes → 512 Base4096 characters
# Language mappings
SYMBOL_LANGUAGE = {
"NOP": b"noop",
"ADD": b"add",
"SUB": b"sub",
"MUL": b"mul",
"DIV": b"div",
"PUSH": b"push",
"POP": b"pop",
"CALL": b"call",
"RET": b"ret",
"RECURSE": b"recurse",
"PRINT": b"print",
"ASSERT": b"assert",
"HALT": b"halt",
}
# Reverse map
REVERSE_SYMBOL_LANGUAGE = {v: k for k, v in SYMBOL_LANGUAGE.items()}
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def compile_to_symbol512(program: str) -> str:
lines = program.strip().splitlines()
binary = b"\n".join([SYMBOL_LANGUAGE.get(line.strip().split()[0].upper(), b"nop") + b" " + b" ".join(word.encode() for word in line.strip().split()[1:]) for line in lines])
digest = hashlib.sha256(binary).digest()
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = hkdf_expand_sha256(digest, salt, DOMAIN + VERSION, EXPAND_SIZE)
return encode(expanded)
def decode_symbol512(symbol: str) -> str:
decoded_bytes = decode(symbol)
commands = []
for i in range(0, len(decoded_bytes), 16):
chunk = decoded_bytes[i:i+16].rstrip(b"\x00")
if not chunk:
continue
parts = chunk.split(b" ", 1)
op = parts[0].strip()
args = parts[1:] if len(parts) > 1 else []
command = REVERSE_SYMBOL_LANGUAGE.get(op, "NOP")
commands.append(f"{command} {' '.join(arg.decode(errors='ignore') for arg in args)}")
return "\n".join(commands)
# Example usage
if __name__ == "__main__":
code = """
PUSH 5
PUSH 10
ADD
PRINT
HALT
"""
print("Human Code:")
print(code)
symbol = compile_to_symbol512(code)
print("\nEncoded Symbol512:")
print(symbol)
decoded = decode_symbol512(symbol)
print("\nDecoded Back to Human Code:")
print(decoded)
# symbolic_vm_transcompiler.py
# Transcompiler between human-readable instructions and Symbol512 code
# Author: Josef Kulovany - ZCHG.org
import hashlib
import hmac
from base4096 import encode, decode
# Constants
VERSION = b'\x01'
DOMAIN = b'Symbol512-Recursive-VM'
EXPAND_BITS = 512 # bits per symbol
EXPAND_BYTES = EXPAND_BITS // 8
# Base operator map (can be expanded)
OPCODES = {
'NOP': b'\x00',
'PUSH': b'\x01',
'POP': b'\x02',
'ADD': b'\x03',
'SUB': b'\x04',
'MUL': b'\x05',
'DIV': b'\x06',
'PRINT': b'\x07',
'HALT': b'\xFF'
}
# Inverse map
OPCODES_INV = {v: k for k, v in OPCODES.items()}
def canonical_expand(data: bytes, salt: bytes, info: bytes, length: int) -> bytes:
out, prev = b"", b""
for i in range(1, (length // 32) + 2):
prev = hmac.new(salt, prev + info + bytes([i]), hashlib.sha256).digest()
out += prev
return out[:length]
def human_to_symbol(instructions: list[str]) -> str:
"""Compile human-readable ops into Symbol512 fingerprint"""
bytecode = b""
for instr in instructions:
parts = instr.strip().split()
op = parts[0].upper()
bytecode += OPCODES[op]
if len(parts) > 1:
arg = int(parts[1]).to_bytes(4, 'big') # Expand later
bytecode += arg
digest = hashlib.sha256(bytecode).digest()
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = canonical_expand(digest, salt, DOMAIN + VERSION, EXPAND_BYTES)
return encode(expanded)
def symbol_to_human(symbol_code: str) -> list[str]:
"""Decompile Symbol512 fingerprint into human-readable instructions (best-effort)"""
raw = decode(symbol_code)
approx_bytes = raw[:32] # reverse SHA-256 input isn't precise, so stub
ptr = 0
instructions = []
while ptr < len(approx_bytes):
opcode = approx_bytes[ptr:ptr+1]
ptr += 1
name = OPCODES_INV.get(opcode, f'UNK_{opcode.hex()}')
if name == 'PUSH':
val = int.from_bytes(approx_bytes[ptr:ptr+4], 'big')
ptr += 4
instructions.append(f'PUSH {val}')
else:
instructions.append(name)
return instructions
if __name__ == "__main__":
sample = ["PUSH 42", "PUSH 17", "ADD", "PRINT", "HALT"]
print("Original:", sample)
encoded = human_to_symbol(sample)
print("Encoded Symbol512:", encoded)
recovered = symbol_to_human(encoded)
print("Recovered:", recovered)
# symbol_program_compiler.py
# Author: Josef Kulovany - ZCHG.org
# Compiles human-readable SymbolPrograms into SymbolNodes for the SymbolVM
import hashlib
import hmac
from base4096 import encode
from symbol_vm_core import SymbolNode, SymbolHypergraph, derive_gradient_operator
SYMBOL_BIT_LENGTH = 512 # Each Symbol encodes 512 bits (64 bytes)
DOMAIN = b"ZCHG-SymbolProgram"
VERSION = b"\x01"
def symbol_hash(data: bytes) -> str:
"""Hashes and encodes 512-bit symbol from source data."""
digest = hashlib.sha512(data).digest() # 64 bytes
return encode(digest) # Base4096 representation
def compile_symbol_program(lines):
"""
Compiles a human-readable SymbolProgram into a hypergraph of SymbolNodes.
Each line defines a symbolic instruction or identity with optional children.
Example input:
LOAD $a
ADD $a, $b
IF $a > $b THEN JUMP label1
label1:
HALT
"""
graph = SymbolHypergraph()
label_map = {}
node_chain = []
for idx, line in enumerate(lines):
stripped = line.strip()
if not stripped:
continue
if stripped.endswith(":"):
label = stripped[:-1]
label_map[label] = len(node_chain)
continue
symbol_bits = hashlib.sha512(stripped.encode()).digest()
symbol_encoded = encode(symbol_bits)
gradient = derive_gradient_operator(symbol_bits, idx)
node = SymbolNode(symbol512=symbol_encoded, gradient_op=[gradient], metadata={"source": stripped})
graph.add_node(node)
node_chain.append(symbol_encoded)
# Connect to previous
if len(node_chain) > 1:
graph.connect(node_chain[-2], node_chain[-1], condition=gradient)
# Post-process labels for jump resolution
for node_id in node_chain:
node = graph.nodes[node_id]
src = node.metadata.get("source", "")
if "JUMP" in src:
parts = src.split()
if "JUMP" in parts:
idx = parts.index("JUMP")
if idx + 1 < len(parts):
label = parts[idx + 1]
if label in label_map:
dest_sym = node_chain[label_map[label]]
graph.connect(node.symbol512, dest_sym, condition="JUMP")
return graph
if __name__ == "__main__":
program = [
"LOAD $a",
"LOAD $b",
"ADD $a, $b",
"IF $a > $b THEN JUMP end",
"MUL $a, 2",
"end:",
"HALT"
]
sym_graph = compile_symbol_program(program)
print(f"Compiled {len(sym_graph.nodes)} symbols into graph.")
for sym in sym_graph.nodes:
print("Symbol:", sym, "→ Gradient:", sym_graph.nodes[sym].gradient_op)
# symbolvm_engine.py
# Author: Josef Kulovany - ZCHG.org
# SymbolVM Execution Engine + Hypergraph Visual Debugger
import hashlib
import hmac
import networkx as nx
import matplotlib.pyplot as plt
from base4096 import encode, decode
# --- Symbol Utilities ---
VERSION = b"\x01"
DOMAIN = b"ZCHG-Symbol512"
EXPAND_BITS = 512
EXPAND_BYTES = EXPAND_BITS // 8
def symbol_hash(payload: bytes) -> bytes:
salt = hashlib.sha256(VERSION + DOMAIN).digest()
return hmac.new(salt, payload, hashlib.sha512).digest()[:EXPAND_BYTES]
def symbol_encode(payload: bytes) -> str:
return encode(payload)
def symbol_decode(encoded: str) -> bytes:
return decode(encoded)
# --- SymbolVM Program Node ---
class SymbolNode:
def __init__(self, label, payload, operator=None):
self.label = label
self.payload = payload # raw string or bytes
self.operator = operator or "id"
self.children = [] # sub-symbols (edges)
self.encoded = symbol_encode(symbol_hash(payload.encode() if isinstance(payload, str) else payload))
def add_child(self, child_node):
self.children.append(child_node)
def __repr__(self):
return f"SymbolNode(label={self.label}, op={self.operator}, symbol={self.encoded[:10]}...)"
# --- SymbolVM Hypergraph Compiler ---
def compile_to_symbol_graph(source_code: str):
lines = [l.strip() for l in source_code.splitlines() if l.strip() and not l.strip().startswith("#")]
root = SymbolNode("root", "program")
last_node = root
for line in lines:
if line.startswith("=>"):
# define operator chain
op = line[2:].strip()
op_node = SymbolNode(f"op:{op}", op.encode(), operator=op)
last_node.add_child(op_node)
last_node = op_node
else:
node = SymbolNode(f"stmt:{line[:10]}", line)
last_node.add_child(node)
return root
# --- SymbolVM Executor ---
def execute_symbol_tree(node: SymbolNode, depth=0):
indent = " " * depth
print(f"{indent}- Executing {node.label} [{node.operator}]")
if node.operator == "id":
pass # Identity operator, do nothing
elif node.operator == "print":
print(f"{indent} Output: {node.payload}")
# TODO: Add gradient/op lookup logic
for child in node.children:
execute_symbol_tree(child, depth + 1)
# --- Visual Debugger ---
def visualize_symbol_tree(root: SymbolNode):
G = nx.DiGraph()
labels = {}
def walk(node, parent_id=None):
node_id = id(node)
labels[node_id] = f"{node.label}\n{node.operator}"
G.add_node(node_id)
if parent_id:
G.add_edge(parent_id, node_id)
for child in node.children:
walk(child, node_id)
walk(root)
pos = nx.spring_layout(G, seed=42)
plt.figure(figsize=(12, 8))
nx.draw(G, pos, with_labels=False, arrows=True, node_color="#ddf", node_size=1500)
nx.draw_networkx_labels(G, pos, labels)
plt.title("SymbolVM Hypergraph Debug View")
plt.show()
# --- Example Program ---
if __name__ == "__main__":
program = """
=> print
Hello from SymbolVM
=> print
Another instruction
"""
root_node = compile_to_symbol_graph(program)
print("\n--- EXECUTION ---")
execute_symbol_tree(root_node)
print("\n--- VISUALIZATION ---")
visualize_symbol_tree(root_node)
# Native symbolic editor + FPCE signing, loading, and base4096 serialization
# Dependencies: tkinter (for UI), base4096.py must implement encode()/decode() for Base-4096 encoding
import json
import hashlib
import hmac
import tkinter as tk
from tkinter import simpledialog
import math
from base4096 import encode, decode # You must provide this implementation
VERSION = b'\x01'
DOMAIN = b'ZCHG-Base4096-Fingerprint'
EXPAND_SIZE = 384 # 256 base4096 characters
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def canonical_fingerprint(txt: str) -> str:
flattened = txt.replace("\n", "").encode("utf-8")
digest = hashlib.sha256(flattened).digest()
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = hkdf_expand_sha256(digest, salt, DOMAIN + VERSION, EXPAND_SIZE)
result = encode(expanded)
assert len(result) == 256
return result
class SymbolNode:
def __init__(self, symbol, x=0, y=0, color='lightblue'):
self.symbol = symbol
self.x = x
self.y = y
self.color = color
self.edges = []
def add_edge(self, node):
if node not in self.edges:
self.edges.append(node)
class HypergraphVMEditor(tk.Tk):
NODE_RADIUS = 20
def __init__(self):
super().__init__()
self.title("Symbolic Hypergraph VM Editor with FPCE")
self.geometry("1000x700")
self.canvas = tk.Canvas(self, bg="white")
self.canvas.pack(fill=tk.BOTH, expand=True)
self.nodes = []
self.selected_node = None
self.dragging = False
self.build_sample_graph()
self.layout_nodes()
self.draw_graph()
self.canvas.bind("<ButtonPress-1>", self.on_click)
self.canvas.bind("<ButtonRelease-1>", self.on_release)
self.canvas.bind("<B1-Motion>", self.on_drag)
self.canvas.bind("<Double-1>", self.on_double_click)
def build_sample_graph(self):
for i, sym in enumerate('ABCDE'):
node = SymbolNode(sym)
self.nodes.append(node)
self.nodes[0].add_edge(self.nodes[1])
self.nodes[0].add_edge(self.nodes[2])
self.nodes[1].add_edge(self.nodes[3])
self.nodes[2].add_edge(self.nodes[4])
def layout_nodes(self):
n = len(self.nodes)
cx, cy = 500, 350
r = 200
for i, node in enumerate(self.nodes):
angle = 2 * math.pi * i / n
node.x = cx + r * math.cos(angle)
node.y = cy + r * math.sin(angle)
def draw_graph(self):
self.canvas.delete("all")
for node in self.nodes:
for target in node.edges:
self.canvas.create_line(node.x, node.y, target.x, target.y, fill='black', width=2)
for node in self.nodes:
self.canvas.create_oval(
node.x - self.NODE_RADIUS,
node.y - self.NODE_RADIUS,
node.x + self.NODE_RADIUS,
node.y + self.NODE_RADIUS,
fill=node.color, outline='black', width=2)
self.canvas.create_text(node.x, node.y, text=node.symbol, font=("Consolas", 20))
def find_node_at(self, x, y):
for node in self.nodes:
dx = x - node.x
dy = y - node.y
if dx * dx + dy * dy <= self.NODE_RADIUS ** 2:
return node
return None
def on_click(self, event):
node = self.find_node_at(event.x, event.y)
if node:
self.selected_node = node
self.dragging = True
self.offset_x = node.x - event.x
self.offset_y = node.y - event.y
else:
self.selected_node = None
def on_release(self, event):
self.dragging = False
def on_drag(self, event):
if self.dragging and self.selected_node:
self.selected_node.x = event.x + self.offset_x
self.selected_node.y = event.y + self.offset_y
self.draw_graph()
def on_double_click(self, event):
node = self.find_node_at(event.x, event.y)
if node:
new_sym = simpledialog.askstring("Edit Symbol", "Enter new Base4096 symbol:", initialvalue=node.symbol)
if new_sym and len(new_sym) == 1:
node.symbol = new_sym
self.draw_graph()
def serialize_graph(self):
id_map = {node: idx for idx, node in enumerate(self.nodes)}
serialized_nodes = []
for node in self.nodes:
node_dict = {
'id': id_map[node],
'symbol': node.symbol,
'x': node.x,
'y': node.y,
'color': node.color,
'edges': [id_map[edge] for edge in node.edges],
}
serialized_nodes.append(node_dict)
graph_dict = {
'nodes': serialized_nodes,
'version': 1,
'description': "Symbolic Hypergraph with FPCE signature",
}
return json.dumps(graph_dict, separators=(',', ':'))
def save_graph_to_file(self, filename):
json_str = self.serialize_graph()
fpce_signature = canonical_fingerprint(json_str)
encoded_graph = encode(json_str.encode('utf-8'))
with open(filename, 'w', encoding='utf-8') as f:
f.write("---BEGIN SYMBOLIC HYPERGRAPH FPCE FILE---\n")
f.write(f"Signature: {fpce_signature}\n")
f.write(f"Encoded-Length: {len(encoded_graph)}\n\n")
f.write(encoded_graph)
f.write("\n---END SYMBOLIC HYPERGRAPH FPCE FILE---\n")
print(f"Graph saved with FPCE signature to {filename}")
def load_graph_from_file(self, filename):
with open(filename, 'r', encoding='utf-8') as f:
lines = f.read().splitlines()
if lines[0] != "---BEGIN SYMBOLIC HYPERGRAPH FPCE FILE---" or lines[-1] != "---END SYMBOLIC HYPERGRAPH FPCE FILE---":
raise ValueError("Invalid file format")
signature = lines[1].split(":", 1)[1].strip()
encoded_length = int(lines[2].split(":", 1)[1].strip())
encoded_graph = ''.join(lines[4:-1])
if len(encoded_graph) != encoded_length:
raise ValueError("Encoded length mismatch")
json_bytes = decode(encoded_graph)
json_str = json_bytes.decode('utf-8')
computed_signature = canonical_fingerprint(json_str)
if computed_signature != signature:
raise ValueError("FPCE signature mismatch! File may be corrupted.")
graph_dict = json.loads(json_str)
self.nodes.clear()
node_map = {}
for node_dict in graph_dict['nodes']:
node = SymbolNode(node_dict['symbol'], node_dict['x'], node_dict['y'], node_dict['color'])
node_map[node_dict['id']] = node
self.nodes.append(node)
for node_dict in graph_dict['nodes']:
node = node_map[node_dict['id']]
for edge_id in node_dict['edges']:
node.add_edge(node_map[edge_id])
self.draw_graph()
print(f"Graph loaded successfully from {filename}")
if __name__ == "__main__":
app = HypergraphVMEditor()
button_frame = tk.Frame(app)
button_frame.pack(side=tk.BOTTOM, fill=tk.X)
save_btn = tk.Button(button_frame, text="Save Graph with FPCE", command=lambda: app.save_graph_to_file("saved_hypergraph.fpce"))
save_btn.pack(side=tk.LEFT, padx=5, pady=5)
load_btn = tk.Button(button_frame, text="Load Graph with FPCE", command=lambda: app.load_graph_from_file("saved_hypergraph.fpce"))
load_btn.pack(side=tk.LEFT, padx=5, pady=5)
app.mainloop()
# symbolvm_fpce_engine.py
# Author: Josef Kulovany - ZCHG.org
# Fully integrated SymbolVM execution engine with Base4096 + FPCE signing
import hashlib
import hmac
import zlib
import json
from typing import List, Dict, Optional
from base4096 import encode as b4096e, decode as b4096d
VERSION = b'\x01'
DOMAIN = b'ZCHG-SymbolVM'
EXPAND_SIZE = 384 # 256 base4096 characters
# ---------- Symbol Definitions ----------
class Symbol:
def __init__(self, id: str, code: str, refs: Optional[List[str]] = None):
self.id = id
self.code = code # could be lambda, expression, opcode, etc.
self.refs = refs or []
def execute(self, context: Dict[str, 'Symbol'], stack: List[str]) -> str:
stack.append(self.id)
try:
if self.code.startswith('lit:'):
return self.code[4:]
elif self.code.startswith('sym:'):
ref_id = self.code[4:]
return context[ref_id].execute(context, stack)
elif self.code.startswith('cat:'):
parts = [context[r].execute(context, stack) for r in self.refs]
return ''.join(parts)
else:
return self.code # raw code fallback
finally:
stack.pop()
# ---------- FPCE Signing ----------
def hkdf_expand_sha256(secret: bytes, salt: bytes, info: bytes, length: int) -> bytes:
blocks = []
output = b''
prev = b''
counter = 1
while len(output) < length:
data = prev + info + bytes([counter])
prev = hmac.new(salt, data, hashlib.sha256).digest()
output += prev
counter += 1
return output[:length]
def fpce_sign(payload: str) -> str:
digest = hashlib.sha256(payload.encode()).digest()
salt = hashlib.sha256(VERSION + DOMAIN).digest()
expanded = hkdf_expand_sha256(digest, salt, DOMAIN + VERSION, EXPAND_SIZE)
return b4096e(expanded)
# ---------- Serialization ----------
def serialize_symbol_tree(symbols: Dict[str, Symbol]) -> str:
data = {
'version': 1,
'symbols': {
sid: {'code': s.code, 'refs': s.refs} for sid, s in symbols.items()
}
}
raw = json.dumps(data, sort_keys=True)
comp = zlib.compress(raw.encode())
return b4096e(comp)
def deserialize_symbol_tree(encoded: str) -> Dict[str, Symbol]:
comp = b4096d(encoded)
raw = zlib.decompress(comp).decode()
obj = json.loads(raw)
symbols = {
sid: Symbol(sid, d['code'], d.get('refs'))
for sid, d in obj['symbols'].items()
}
return symbols
# ---------- Execution and Bundle ----------
def evaluate_and_sign(symbols: Dict[str, Symbol], root_id: str) -> Dict:
output = symbols[root_id].execute(symbols, [])
serialized = serialize_symbol_tree(symbols)
signature = fpce_sign(serialized)
return {
'output': output,
'base4096': serialized,
'signature': signature
}
# ---------- Example ----------
if __name__ == '__main__':
symbols = {
'A': Symbol('A', 'lit:Hello'),
'B': Symbol('B', 'lit:World'),
'C': Symbol('C', 'cat:', refs=['A', 'B']),
'ROOT': Symbol('ROOT', 'sym:C')
}
result = evaluate_and_sign(symbols, 'ROOT')
print("\nOutput:", result['output'])
print("\nSerialized Base4096:\n", result['base4096'])
print("\nSignature (FPCE):\n", result['signature'])
# SymbolVM Visual Editor (Post-Browser Native)
# Author: Josef Kulovany - ZCHG.org
# UI Framework: Tkinter (native, minimal)
# Graph Engine: NetworkX + Matplotlib (optional)
# Purpose: Explore, edit, sign, and execute SymbolVM hypergraph trees
import tkinter as tk
from tkinter import filedialog, simpledialog, messagebox
import networkx as nx
import matplotlib.pyplot as plt
from base4096 import encode, decode
from chain_fpce import canonical_fingerprint, chain_fpce
import hashlib
class SymbolNode:
def __init__(self, symbol, op=None, children=None):
self.symbol = symbol
self.op = op or "NOP"
self.children = children or []
class SymbolEditor:
def __init__(self, master):
self.master = master
self.master.title("SymbolVM Hypergraph Editor")
self.symbols = {} # symbol -> SymbolNode
self.graph = nx.DiGraph()
self.canvas = tk.Canvas(master, width=800, height=600, bg='white')
self.canvas.pack(fill=tk.BOTH, expand=True)
self.toolbar = tk.Frame(master)
self.toolbar.pack()
tk.Button(self.toolbar, text="Add Symbol", command=self.add_symbol).pack(side=tk.LEFT)
tk.Button(self.toolbar, text="Link", command=self.link_symbols).pack(side=tk.LEFT)
tk.Button(self.toolbar, text="Visualize", command=self.draw_graph).pack(side=tk.LEFT)
tk.Button(self.toolbar, text="Sign", command=self.sign_tree).pack(side=tk.LEFT)
tk.Button(self.toolbar, text="Save", command=self.save_serialized).pack(side=tk.LEFT)
def add_symbol(self):
s = simpledialog.askstring("Symbol", "Enter symbol:")
if not s: return
op = simpledialog.askstring("Operator", "Enter operator (default NOP):") or "NOP"
self.symbols[s] = SymbolNode(s, op)
self.graph.add_node(s, op=op)
def link_symbols(self):
src = simpledialog.askstring("From", "Parent symbol:")
dst = simpledialog.askstring("To", "Child symbol:")
if src in self.symbols and dst in self.symbols:
self.symbols[src].children.append(dst)
self.graph.add_edge(src, dst)
def draw_graph(self):
plt.figure(figsize=(8,6))
pos = nx.spring_layout(self.graph)
nx.draw(self.graph, pos, with_labels=True, node_color='lightblue')
labels = nx.get_node_attributes(self.graph, 'op')
nx.draw_networkx_labels(self.graph, pos, labels=labels)
plt.title("SymbolVM Hypergraph")
plt.show()
def serialize_tree(self):
lines = []
for sym, node in self.symbols.items():
line = f"{sym}:{node.op}:{','.join(node.children)}"
lines.append(line)
return "\n".join(lines)
def sign_tree(self):
data = self.serialize_tree()
chain = chain_fpce(data)
messagebox.showinfo("Signature", f"Depth: {len(chain)}\nFinal Fingerprint:\n{chain[-1]}")
def save_serialized(self):
data = self.serialize_tree()
b4096_encoded = encode(data.encode())
file = filedialog.asksaveasfilename(defaultextension=".b4096")
if file:
with open(file, "w", encoding="utf-8") as f:
f.write(b4096_encoded)
messagebox.showinfo("Saved", f"Serialized + encoded structure saved as {file}")
if __name__ == "__main__":
root = tk.Tk()
app = SymbolEditor(root)
root.mainloop()
