HTQ32 AMOLF2013
Quantum Karjoa Core

Full Algebraic version

PYTHON
Copier le code
# ==================================
# HTQ32 AMOLF2013
# Quantum KarJoa Core
# Full Algebraic Version
# Working PAT / Machine-ready draft
# AMOLF2013 linked / IT3
# HT CONSTANT
# Y Axis : routing & operators
# Pi-Metre / Octave / Cycle || Seconde
# Conservation angulaire / 2 régimes
# Hidden structure on Y Axis

# ============================================================

import math
from dataclasses import dataclass, asdict
from typing import List, Tuple, Dict, Any

# ------------------------------------------------------------
# 1. STRUCTURES
# ------------------------------------------------------------
@dataclass
class HTQ32Vector:
prime: int
prime_rank: int
theta: float
q32_index: int
density: int
rotation: int

@dataclass
class HTQ32State:
input_value: int
primes: List[int]
vectors: List[HTQ32Vector]
collatz_sequence: List[int]
density_summary: Dict[str, float]
q32_distribution: Dict[int, int]
density_distribution: Dict[int, int]
rotation_distribution: Dict[int, int]
axes: Dict[str, str]
htq32_meta: Dict[str, int]

# ------------------------------------------------------------
# 2. PRIMALITE
# ------------------------------------------------------------
def is_prime(n: int) -> bool:
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for k in range(3, int(math.sqrt(n)) + 1, 2):
if n % k == 0:
return False
return True

def primes_to(N: int) -> List[int]:
return [n for n in range(2, N + 1) if is_prime(n)]

# ------------------------------------------------------------
# 3. MAPPING
# ------------------------------------------------------------
def prime_to_theta(p: int) -> float:
return math.pi / p

def rank_to_q32(r: int) -> int:
return r % 32

def rank_to_density(r: int) -> int:
return (r % 8) + 1

def rank_to_rotation(r: int) -> int:
return (r % 4) + 1

def prime_to_q32_vector(p: int, r: int) -> HTQ32Vector:
return HTQ32Vector(
prime=p,
prime_rank=r,
theta=prime_to_theta(p),
q32_index=rank_to_q32(r),
density=rank_to_density(r),
rotation=rank_to_rotation(r),
)

# ------------------------------------------------------------
# 4. COLLATZ
# ------------------------------------------------------------
def collatz(m: int) -> Tuple[List[int], int, int]:
seq = [m]
exp, comp = 0, 0
while m != 1:
if m % 2:
m = 3 * m + 1
exp += 1
else:
m //= 2
comp += 1
seq.append(m)
return seq, exp, comp

def collatz_density(exp: int, comp: int) -> Dict[str, float]:
return {
"expansions": exp,
"compressions": comp,
"total_steps": exp + comp,
"raw_density": exp - comp,
"ratio_density": exp / (comp + 1),
}

# ------------------------------------------------------------
# 5. DISTRIBUTIONS
# ------------------------------------------------------------
def dist_q32(vs: List[HTQ32Vector]) -> Dict[int, int]:
d = {i: 0 for i in range(32)}
for v in vs:
d[v.q32_index] += 1
return d

def dist_density(vs: List[HTQ32Vector]) -> Dict[int, int]:
d = {i: 0 for i in range(1, 9)}
for v in vs:
d[v.density] += 1
return d

def dist_rotation(vs: List[HTQ32Vector]) -> Dict[int, int]:
d = {i: 0 for i in range(1, 5)}
for v in vs:
d[v.rotation] += 1
return d

# ------------------------------------------------------------
# 6. ETAT GLOBAL
# ------------------------------------------------------------
def htq32_state(N: int) -> HTQ32State:
primes = primes_to(N)
vectors = [prime_to_q32_vector(p, r) for r, p in enumerate(primes, start=1)]

seq, exp, comp = collatz(N)
dens = collatz_density(exp, comp)

return HTQ32State(
input_value=N,
primes=primes,
vectors=vectors,
collatz_sequence=seq,
density_summary=dens,
q32_distribution=dist_q32(vectors),
density_distribution=dist_density(vectors),
rotation_distribution=dist_rotation(vectors),
axes={
"X": "ancrage",
"Y": "routing premiers · pi-metre · octave · cycle",
"Z": "exp(i*pi)+1=0",
},
htq32_meta={
"densities": 8,
"rotations": 4,
"vectors_total": 32,
},
)

# ------------------------------------------------------------
# 7. SIGNATURE
# ------------------------------------------------------------
def htq32_signature(state: HTQ32State) -> Dict[str, float]:
n = len(state.vectors)
if n == 0:
return {}

q_probs = [c / n for c in state.q32_distribution.values() if c > 0]
entropy = -sum(p * math.log(p) for p in q_probs)

d_max = max(state.density_distribution.values())
r_max = max(state.rotation_distribution.values())

thetas = [v.theta for v in state.vectors]
t_mean = sum(thetas) / n
t_var = sum((t - t_mean) ** 2 for t in thetas) / n

return {
"q32_entropy": entropy,
"density_balance": d_max / n,
"rotation_balance": r_max / n,
"theta_mean": t_mean,
"theta_variance": t_var,
"collatz_raw_density": state.density_summary["raw_density"],
}

# ------------------------------------------------------------
# 8. EXPORT
# ------------------------------------------------------------
def htq32_state_to_dict(state: HTQ32State) -> Dict[str, Any]:
return {
"input_value": state.input_value,
"primes": state.primes,
"vectors": [asdict(v) for v in state.vectors],
"collatz_sequence": state.collatz_sequence,
"density_summary": state.density_summary,
"q32_distribution": state.q32_distribution,
"density_distribution": state.density_distribution,
"rotation_distribution": state.rotation_distribution,
"axes": state.axes,
"htq32_meta": state.htq32_meta,
}

# ------------------------------------------------------------
# 9. PRINT
# ------------------------------------------------------------
def print_htq32(N: int):
s = htq32_state(N)

print("\nHTQ32 :: N =", N)
print("PRIMES:", s.primes)

for v in s.vectors:
print(f"{v.prime:>3} r{v.prime_rank:>2} Q{v.q32_index:>2} D{v.density} R{v.rotation}")

print("COLLATZ:", s.collatz_sequence)
print("DENSITY:", s.density_summary)
print("SIGNATURE:", htq32_signature(s))

# ------------------------------------------------------------
# 10. TEST
# ------------------------------------------------------------
if __name__ == "__main__":
print_htq32(7)
print_htq32(97)