mirror of
https://github.com/allaunthefox/SilverSight.git
synced 2026-07-30 17:16:16 +00:00
3c35fe50c2
Core components: - ChentsovFinite.lean (883 lines, 0 sorry): Fisher metric uniqueness on 8-state simplex - HachimojiCodec.lean: Deterministic E=mc^2 -> Hachimoji state pipeline - PVGS_DQ_Bridge (8 sections, ~6,150 lines): Photon-Varied Gaussian to Dual Quaternion - UniversalMathEncoding.lean: 50-token math address space (~10^15 addresses) - ChiralitySpace.lean: 4D descriptor (phase x chirality x direction x regime) ~2x10^25 - BindingSite (3 files): Amino acid vocabulary, entropy-based bindability - Python: chaos game, Sidon addressing, Q16.16 canonical, Finsler metric, QUBO/QAOA - CI: Lean check, Python check, Q16 roundtrip workflows Papers: Giani-Win-Conti 2025, Chabaud-Mehraban 2022, Pizzimenti 2024, Wassner 2025
102 lines
3.5 KiB
Python
102 lines
3.5 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
sidon_address.py — Sidon Address Assignment from Spectral Profile
|
|
|
|
Maps an 8D spectral profile to a Sidon address from the set
|
|
{1, 2, 4, 8, 16, 32, 64, 128}. These are the 8 powers of 2, forming
|
|
a Sidon set (B_2 sequence): all pairwise sums a_i + a_j (i ≤ j) are
|
|
distinct. This guarantees collision-free addressing.
|
|
"""
|
|
|
|
import hashlib
|
|
from typing import List
|
|
|
|
# ── Sidon Set ────────────────────────────────────────────────────────────
|
|
SIDON_ADDRESSES = [1, 2, 4, 8, 16, 32, 64, 128]
|
|
|
|
_ADDRESS_TO_STRAND = {addr: i for i, addr in enumerate(SIDON_ADDRESSES)}
|
|
_STRAND_TO_ADDRESS = {i: addr for i, addr in enumerate(SIDON_ADDRESSES)}
|
|
|
|
# Verify Sidon property at module load
|
|
_SIDON_SUMS = {}
|
|
for i, a in enumerate(SIDON_ADDRESSES):
|
|
for j, b in enumerate(SIDON_ADDRESSES):
|
|
if i <= j:
|
|
s = a + b
|
|
if s in _SIDON_SUMS:
|
|
raise RuntimeError(f"Sidon VIOLATED: {a}+{b}={s}")
|
|
_SIDON_SUMS[s] = (a, b)
|
|
|
|
|
|
def verify_sidon_property() -> bool:
|
|
seen = set()
|
|
for i, a in enumerate(SIDON_ADDRESSES):
|
|
for j, b in enumerate(SIDON_ADDRESSES):
|
|
if i <= j:
|
|
s = a + b
|
|
if s in seen:
|
|
return False
|
|
seen.add(s)
|
|
return True
|
|
|
|
|
|
def spectral_to_sidon_address(spectral_profile: List[float], hash_val: int = 0) -> List[int]:
|
|
"""Map 8D spectral profile to ordered Sidon address list.
|
|
|
|
Uses the spectral profile weighted by a deterministic hash to select
|
|
the primary strand. The hash ensures different equations map to
|
|
different strands even when their spectral profiles are similar.
|
|
|
|
Args:
|
|
spectral_profile: 8D profile from compute_spectral_profile()
|
|
hash_val: Optional integer hash for diversity (default 0)
|
|
|
|
Returns:
|
|
Ordered list of 8 Sidon addresses, primary first
|
|
"""
|
|
if len(spectral_profile) != 8:
|
|
raise ValueError(f"Expected 8D profile, got {len(spectral_profile)}D")
|
|
|
|
# Blend profile with hash-derived scores for diversity
|
|
scores = []
|
|
for i in range(8):
|
|
profile_score = spectral_profile[i]
|
|
# Hash contribution: deterministic but different per equation
|
|
hash_score = ((hash_val >> (i * 4)) & 0xF) / 16.0
|
|
# Blend: 70% profile, 30% hash (profile dominates structure)
|
|
blended = 0.7 * profile_score + 0.3 * hash_score
|
|
scores.append((i, blended))
|
|
|
|
# Sort by score descending
|
|
sorted_strands = sorted(scores, key=lambda x: x[1], reverse=True)
|
|
|
|
return [SIDON_ADDRESSES[s[0]] for s in sorted_strands]
|
|
|
|
|
|
def hash_to_sidon_address(hash_val: int) -> int:
|
|
return SIDON_ADDRESSES[hash_val % 8]
|
|
|
|
|
|
def address_to_strand(address: int) -> int:
|
|
if address not in _ADDRESS_TO_STRAND:
|
|
raise ValueError(f"Invalid Sidon address: {address}")
|
|
return _ADDRESS_TO_STRAND[address]
|
|
|
|
|
|
def strand_to_address(strand: int) -> int:
|
|
if strand < 0 or strand > 7:
|
|
raise ValueError(f"Invalid strand: {strand}")
|
|
return _STRAND_TO_ADDRESS[strand]
|
|
|
|
|
|
def compute_full_address(equation: str) -> List[int]:
|
|
"""Compute full Sidon address list for an equation."""
|
|
from spectral_profile import compute_spectral_profile
|
|
|
|
profile = compute_spectral_profile(equation)
|
|
h = structural_hash(equation)
|
|
return spectral_to_sidon_address(profile, h)
|
|
|
|
|
|
def structural_hash(equation: str) -> int:
|
|
return int(hashlib.sha256(equation.encode()).hexdigest(), 16)
|