Spaces:
Running
Running
| #!/usr/bin/env python3 | |
| # SPDX-License-Identifier: Apache-2.0 | |
| """NEXUS hologram — stdlib analog computer. No npm. No Gradio. Port 7860. | |
| Six integrator programs (Lorenz, harmonic, van der Pol, Duffing, | |
| Lotka–Volterra, NEMO analog neuromorphic) plus a two-beam optical analog. | |
| Energy UNAVAILABLE. Λ uniqueness is Conjecture 1. Not a physical chip. | |
| The full Web Audio instrument stays on github.com/szl-holdings/nexus. | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import math | |
| import os | |
| import sys | |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer | |
| from pathlib import Path | |
| from typing import Any | |
| from urllib.parse import urlparse | |
| HTML = Path(__file__).with_name("index.html") | |
| SIGMA, RHO, BETA = 10.0, 28.0, 8.0 / 3.0 | |
| DT = 0.01 | |
| YUYAY_FLOORS = (0.95, 0.95) + (0.90,) * 11 | |
| ORGANS = ("YACHAY", "YUYAY", "YAWAR", "NERVOUS", "KHIPU") | |
| PROGRAMS = ("lorenz", "harmonic", "vanderpol", "duffing", "lotka", "nemo") | |
| PROGRAM_LABELS = { | |
| "lorenz": "LRNZ", | |
| "harmonic": "HARM", | |
| "vanderpol": "VDP", | |
| "duffing": "DFFG", | |
| "lotka": "LTKA", | |
| "nemo": "NEMO", | |
| } | |
| def clamp01(c: float) -> float: | |
| return min(1.0, max(0.0, float(c))) | |
| def lambda_aggregate(axes: list[float]) -> float: | |
| if not axes: | |
| raise ValueError("axes empty") | |
| if any(x < 0 for x in axes): | |
| raise ValueError("axes must be >= 0") | |
| if any(x == 0 for x in axes): | |
| return 0.0 | |
| w = 1.0 / len(axes) | |
| return math.exp(sum(w * math.log(x) for x in axes)) | |
| def lorenz_rk4(x: float, y: float, z: float, steps: int, dt: float = DT) -> list[list[float]]: | |
| """Compat trail. New work uses analog_step (Euler, matches the instrument).""" | |
| steps = max(1, min(int(steps), 2400)) | |
| trail: list[list[float]] = [] | |
| def f(px: float, py: float, pz: float) -> tuple[float, float, float]: | |
| return (SIGMA * (py - px), px * (RHO - pz) - py, px * py - BETA * pz) | |
| for _ in range(steps): | |
| k1 = f(x, y, z) | |
| k2 = f(x + 0.5 * dt * k1[0], y + 0.5 * dt * k1[1], z + 0.5 * dt * k1[2]) | |
| k3 = f(x + 0.5 * dt * k2[0], y + 0.5 * dt * k2[1], z + 0.5 * dt * k2[2]) | |
| k4 = f(x + dt * k3[0], y + dt * k3[1], z + dt * k3[2]) | |
| x += dt * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]) / 6 | |
| y += dt * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]) / 6 | |
| z += dt * (k1[2] + 2 * k2[2] + 2 * k3[2] + k4[2]) / 6 | |
| trail.append([x, y, z]) | |
| return trail | |
| def seed_lorenz(nudge: float = 0.0) -> dict[str, Any]: | |
| return { | |
| "x": 0.12 + nudge * 0.31, | |
| "y": -0.08 + nudge * 0.17, | |
| "z": 22 + (nudge % 1) * 6, | |
| "t": 0.0, | |
| } | |
| def seed_nemo_bank(nudge: float = 0.0) -> list[float]: | |
| n = nudge % 1 | |
| v = [-65 + n * 6, -62 - n * 4, -70 + n * 5, -58 - n * 3, -67 + n * 8] | |
| u = [0.2 * m for m in v] | |
| return [*v, *u, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0] | |
| def pad_nemo_bank(raw: Any) -> list[float]: | |
| if isinstance(raw, list) and len(raw) >= 20 and all(math.isfinite(float(n)) for n in raw[:20]): | |
| return [float(n) for n in raw[:20]] | |
| if isinstance(raw, list) and len(raw) == 15 and all(math.isfinite(float(n)) for n in raw): | |
| return [float(n) for n in raw] + [1.0] * 5 | |
| return seed_nemo_bank() | |
| def seed_analog(program: str, nudge: float = 0.0) -> dict[str, Any]: | |
| n = nudge % 1 | |
| if program == "harmonic": | |
| return {"x": 1.0, "y": 0.02 + n * 0.08, "z": 0.5, "t": 0.0} | |
| if program == "vanderpol": | |
| return {"x": 0.12 + n * 0.2, "y": 0.04, "z": 0.4, "t": 0.0} | |
| if program == "duffing": | |
| return {"x": 0.18 + n * 0.12, "y": 0.0, "z": 0.5, "t": 0.0} | |
| if program == "lotka": | |
| return {"x": 1.15 + n * 0.25, "y": 0.82 + n * 0.12, "z": 0.5, "t": 0.0} | |
| if program == "nemo": | |
| bank = seed_nemo_bank(nudge) | |
| return {"x": bank[0], "y": bank[2], "z": 0.06, "t": 0.0, "bank": bank} | |
| L = seed_lorenz(nudge) | |
| return L | |
| def analog_coefficients(chaos: float, program: str = "lorenz") -> dict[str, Any]: | |
| c = clamp01(chaos) | |
| if program == "harmonic": | |
| omega = 1 + c * 3 | |
| return { | |
| "sigma": 10, "rho": 18 + c * 22, "beta": 8 / 3, "omega": omega, | |
| "mu": 0, "delta": 0, "gamma": 0, "alpha": 0, | |
| "label": f"ω {omega:.2f}", | |
| } | |
| if program == "vanderpol": | |
| mu = 0.25 + c * 2.7 | |
| return { | |
| "sigma": 10, "rho": 18 + c * 22, "beta": 8 / 3, "omega": 1, | |
| "mu": mu, "delta": 0, "gamma": 0, "alpha": 0, | |
| "label": f"μ {mu:.2f}", | |
| } | |
| if program == "duffing": | |
| delta = 0.08 + c * 0.32 | |
| gamma = 0.18 + c * 0.55 | |
| return { | |
| "sigma": 10, "rho": 18 + c * 22, "beta": 8 / 3, "omega": 1.2, | |
| "mu": 0, "delta": delta, "gamma": gamma, "alpha": 0, | |
| "label": f"δ {delta:.2f} · γ {gamma:.2f}", | |
| } | |
| if program == "lotka": | |
| alpha = 0.85 + c * 0.55 | |
| beta = 0.42 + c * 0.7 | |
| return { | |
| "sigma": 10, "rho": 18 + c * 22, "beta": 8 / 3, "omega": 1, | |
| "mu": 0, "delta": 0.4 + c * 0.35, "gamma": 0.62, "alpha": alpha, | |
| "label": f"α {alpha:.2f} · β {beta:.2f}", | |
| } | |
| if program == "nemo": | |
| a = 0.02 + c * 0.08 | |
| w = 3.5 + c * 14 | |
| tau = 3 + (1 - c) * 9 | |
| return { | |
| "sigma": 10, "rho": 18 + c * 22, "beta": 8 / 3, "omega": 1, | |
| "mu": a, "delta": w, "gamma": tau, "alpha": 0.2, | |
| "label": "AdEx · 5ORG · 2BRN", | |
| } | |
| rho = 18 + c * 22 | |
| return { | |
| "sigma": 10, "rho": rho, "beta": 8 / 3, "omega": 1, | |
| "mu": 0, "delta": 0, "gamma": 0, "alpha": 0, | |
| "label": f"σ 10 · ρ {rho:.1f} · β {(8 / 3):.2f}", | |
| } | |
| def optical_interfere(obj_amp: float, obj_phase: float, ref_amp: float, ref_phase: float) -> float: | |
| """Two-beam analog optical inner product. Not a digital FFT. Energy UNAVAILABLE.""" | |
| ao = max(0.0, float(obj_amp)) | |
| ar = max(0.0, float(ref_amp)) | |
| intensity = ao * ao + ar * ar + 2 * ao * ar * math.cos(obj_phase - ref_phase) | |
| if not math.isfinite(intensity): | |
| return 0.0 | |
| return max(0.0, intensity) | |
| def optical_reconstruct(intensity: float, dphi: float) -> float: | |
| v = intensity * math.cos(dphi) | |
| if not math.isfinite(v): | |
| return 0.0 | |
| return max(-1.0, min(1.0, v / 2.0)) | |
| def analog_circuit(x: float, y: float, z: float, corr: float = 0.0) -> dict[str, float]: | |
| """THAT analog-element *jobs* as live voltages. Not the circuit.""" | |
| def u(n: float) -> float: | |
| v = float(n) if math.isfinite(float(n)) else 0.0 | |
| return max(-1.0, min(1.0, v)) | |
| xi, yi, zi = u(x), u(y), u(z) | |
| return { | |
| "intg": xi, | |
| "sum": u((xi + yi + zi) / 3.0), | |
| "mul": u(xi * yi), | |
| "inv": u(-xi), | |
| "cmp": 1.0 if xi >= 0 else -1.0, | |
| "corr": u(corr), | |
| } | |
| def analog_correlate(pre: float, post: float, corr: float, dt: float, tau: float = 0.18) -> float: | |
| """Leaky analog correlator — BrainScaleS analog-correlator *job*, not the chip.""" | |
| def u(n: float) -> float: | |
| v = float(n) if math.isfinite(float(n)) else 0.0 | |
| return max(-1.0, min(1.0, v)) | |
| product = u(pre) * u(post) | |
| t = max(1e-4, float(tau)) | |
| a = 1.0 - math.exp(-max(0.0, float(dt)) / t) | |
| prev = u(corr) | |
| return u(prev + (product - prev) * a) | |
| def analog_schmitt(x: float, last: float, hyst: float = 0.08) -> float: | |
| """Analog Schmitt trigger. Holds last polarity through the hysteresis band.""" | |
| h = max(0.01, min(0.45, float(hyst))) | |
| xi = float(x) if math.isfinite(float(x)) else 0.0 | |
| xi = max(-1.0, min(1.0, xi)) | |
| if last >= 0: | |
| return 1.0 if xi > -h else -1.0 | |
| return -1.0 if xi < h else 1.0 | |
| def analog_jack(ckt: dict[str, float], recon: float, drive: float) -> float: | |
| d = clamp01(drive) | |
| r = max(-1.0, min(1.0, float(recon) if math.isfinite(float(recon)) else 0.0)) | |
| corr = max(-1.0, min(1.0, float(ckt.get("corr", 0.0) or 0.0))) | |
| v = ckt["intg"] * 0.55 + ckt["mul"] * 0.22 * d + corr * 0.12 * d + r * 0.22 * d | |
| return max(-1.0, min(1.0, v)) | |
| def analog_nemo_step(s: dict[str, Any], dt: float, chaos: float, drive: float) -> dict[str, Any]: | |
| """AdEx five-organ anatomy + WILLAY optical second brain. | |
| Brette & Gerstner 2005 membranes (BrainScaleS-2 *job*). Organ jobs: | |
| YACHAY cognition, YUYAY pacemaker If, YAWAR traveling wave (Miller 2026 | |
| analog-wave *job*), OTel optical write, KHIPU bound. WILLAY is the | |
| optical ring — second brain, not a sixth organ. Drive is analog | |
| neuromodulator, not dopamine. Not a physical chip. Energy UNAVAILABLE. | |
| """ | |
| c = clamp01(chaos) | |
| pots = analog_coefficients(c, "nemo") | |
| a_adapt = float(pots["mu"]) | |
| chem_w = float(pots["delta"]) | |
| tau = max(1.4, float(pots["gamma"])) | |
| i0 = 2.2 + drive * 10.5 | |
| el, d_t, g_l = -65.0, 2.0, 0.12 | |
| vt = -52 + c * 6 | |
| tau_w = max(8.0, 42 - c * 28) | |
| vr = -58 + c * 8 | |
| b_jump = 4 + c * 10 | |
| v_peak = 20.0 | |
| mod = clamp01(drive) | |
| bank = pad_nemo_bank(s.get("bank")) | |
| rate = float(s["z"]) if math.isfinite(float(s.get("z", 0))) else 0.0 | |
| rate = max(0.0, min(1.0, rate)) | |
| t = float(s["t"]) if math.isfinite(float(s.get("t", 0))) else 0.0 | |
| total_ms = max(0.25, min(80.0, float(dt) * 1000.0)) | |
| n = max(4, min(48, math.ceil(total_ms / 0.5))) | |
| h = total_ms / n | |
| for _ in range(n): | |
| I = [0.0] * 5 | |
| iopts = [0.0] * 5 | |
| t_ms = t * 1000.0 | |
| pace_t = 170.0 + (1.0 - mod) * 260.0 | |
| i_pace = mod * (1.6 + 3.8 * (0.5 + 0.5 * math.sin((t_ms * math.pi * 2) / pace_t))) | |
| willay_field = 0.0 | |
| for i in range(5): | |
| opp = (i + 2) % 5 | |
| prev = (i + 4) % 5 | |
| ao = max(0.0, (bank[i] + 70) / 110) | |
| ar = max(0.0, (bank[opp] + 70) / 110) | |
| iopts[i] = optical_interfere(ao, bank[i] * 0.035, ar, bank[opp] * 0.035) | |
| willay_field += optical_reconstruct(iopts[i], (bank[i] - bank[opp]) * 0.035) | |
| i_wave = 0.72 * max(0.0, (bank[prev] - el) / 40.0) | |
| wi = max(0.05, min(4.0, bank[15 + i])) | |
| inj = bank[10 + i] + iopts[i] * (1.1 + drive * 0.9) * wi + i_wave | |
| if i == 0: | |
| inj += i0 | |
| elif i == 1: | |
| inj += 0.8 + drive * 2.4 + i_pace | |
| else: | |
| inj += 0.8 + drive * 2.4 | |
| if i == 3: | |
| inj += 0.45 * iopts[i] | |
| I[i] = inj | |
| willay_field /= 5.0 | |
| gate = 0.35 + 0.65 * (0.5 + 0.5 * willay_field) | |
| fired: list[int] = [] | |
| for i in range(5): | |
| vi = bank[i] | |
| ui = bank[5 + i] | |
| si = bank[10 + i] | |
| arg = max(-20.0, min(8.0, (vi - vt) / d_t)) | |
| dv = -g_l * (vi - el) + g_l * d_t * math.exp(arg) - ui + I[i] | |
| du = (a_adapt * (vi - el) - ui) / tau_w | |
| vi += dv * h | |
| ui += du * h | |
| if i == 4: | |
| vi += (el - vi) * (h / 420.0) | |
| si += (-si / tau) * h | |
| if vi >= v_peak: | |
| vi = vr | |
| ui += b_jump | |
| fired.append(i) | |
| bank[i] = max(-90.0, min(40.0, vi)) | |
| bank[5 + i] = max(-40.0, min(80.0, ui)) | |
| bank[10 + i] = max(0.0, min(48.0, si)) | |
| for i in fired: | |
| post = (i + 1) % 5 | |
| opp = (i + 2) % 5 | |
| avail = 1.0 - min(1.0, bank[10 + post] / 48.0) | |
| jump = chem_w * avail * (0.55 + 0.45 * gate) | |
| bank[10 + post] = min(48.0, bank[10 + post] + jump) | |
| nervous = 1.35 if i == 3 else 1.0 | |
| bank[15 + i] = bank[15 + i] + 0.018 * (bank[10 + opp] / 48.0) * iopts[i] * mod * gate * nervous | |
| bank[15 + opp] = bank[15 + opp] - 0.006 | |
| for i in range(5): | |
| leaked = bank[15 + i] + (1.0 - bank[15 + i]) * (h / 180.0) | |
| bank[15 + i] = max(0.05, min(4.0, leaked)) | |
| decay = math.exp(-h / 38.0) | |
| rate = rate * decay + (len(fired) / 5.0) * (1 - decay) * 10 | |
| if rate > 1: | |
| rate = 1.0 | |
| t += h * 0.001 | |
| if not math.isfinite(bank[0]) or not math.isfinite(rate) or not math.isfinite(t): | |
| return seed_analog("nemo") | |
| return {"x": bank[0], "y": bank[2], "z": rate, "t": t, "bank": bank} | |
| def analog_step(program: str, s: dict[str, Any], dt: float, chaos: float, drive: float = 0.5) -> dict[str, Any]: | |
| if program == "nemo": | |
| return analog_nemo_step(s, dt, chaos, drive) | |
| pots = analog_coefficients(chaos, program) | |
| n = 4 | |
| h = max(0.0004, min(0.08, float(dt))) / n | |
| x = float(s.get("x", 0.0)) | |
| y = float(s.get("y", 0.0)) | |
| z = float(s.get("z", 0.0)) | |
| t = float(s.get("t", 0.0)) | |
| for _ in range(n): | |
| if program == "harmonic": | |
| w2 = pots["omega"] * pots["omega"] | |
| dx, dy, dz = y, -w2 * x, 0.0 | |
| elif program == "vanderpol": | |
| dx = y | |
| dy = pots["mu"] * (1 - x * x) * y - x | |
| dz = 0.0 | |
| elif program == "duffing": | |
| force = pots["gamma"] * (0.45 + drive * 0.7) * math.cos(pots["omega"] * t) | |
| dx = y | |
| dy = x - x * x * x - pots["delta"] * y + force | |
| dz = 0.0 | |
| elif program == "lotka": | |
| prey = max(0.02, x) | |
| pred = max(0.02, y) | |
| dx = pots["alpha"] * prey - pots["beta"] * prey * pred | |
| dy = pots["delta"] * prey * pred - pots["gamma"] * pred | |
| dz = 0.0 | |
| else: | |
| dx = pots["sigma"] * (y - x) | |
| dy = x * (pots["rho"] - z) - y | |
| dz = x * y - pots["beta"] * z | |
| x += dx * h | |
| y += dy * h | |
| z += dz * h | |
| t += h | |
| if program == "lotka": | |
| x = max(0.02, x) | |
| y = max(0.02, y) | |
| if not all(math.isfinite(v) for v in (x, y, z, t)): | |
| return seed_analog(program) | |
| return {"x": x, "y": y, "z": z, "t": t} | |
| def scale_analog(program: str, s: dict[str, Any]) -> dict[str, float]: | |
| x, y, z = float(s["x"]), float(s["y"]), float(s["z"]) | |
| if program == "harmonic": | |
| e = 0.5 * (y * y + x * x) | |
| return {"x": max(-1, min(1, x)), "y": max(-1, min(1, y / 3)), "z": max(0, min(1, e * 0.5))} | |
| if program == "vanderpol": | |
| return { | |
| "x": max(-1, min(1, x / 2.4)), | |
| "y": max(-1, min(1, y / 3.2)), | |
| "z": max(0, min(1, (x * x + y * y) / 10)), | |
| } | |
| if program == "duffing": | |
| return { | |
| "x": max(-1, min(1, x / 2)), | |
| "y": max(-1, min(1, y / 2.4)), | |
| "z": max(0, min(1, 0.5 + 0.5 * math.sin(float(s["t"])))), | |
| } | |
| if program == "lotka": | |
| return { | |
| "x": max(-1, min(1, (x - 1.4) / 1.8)), | |
| "y": max(-1, min(1, (y - 1.1) / 1.6)), | |
| "z": max(0, min(1, (x + y) / 6)), | |
| } | |
| if program == "nemo": | |
| return { | |
| "x": max(-1, min(1, (x + 45) / 40)), | |
| "y": max(-1, min(1, (y + 45) / 40)), | |
| "z": max(0, min(1, z)), | |
| } | |
| return { | |
| "x": max(-1, min(1, x / 24)), | |
| "y": max(-1, min(1, y / 24)), | |
| "z": max(0, min(1, z / 48)), | |
| } | |
| def analog_trail( | |
| program: str, | |
| s: dict[str, Any], | |
| steps: int, | |
| chaos: float, | |
| drive: float, | |
| dt: float, | |
| ) -> tuple[list[list[float]], dict[str, Any]]: | |
| cap = 400 if program == "nemo" else 2400 | |
| steps = max(1, min(int(steps), cap)) | |
| trail: list[list[float]] = [] | |
| state = dict(s) | |
| for _ in range(steps): | |
| state = analog_step(program, state, dt, chaos, drive) | |
| trail.append([state["x"], state["y"], state["z"]]) | |
| return trail, state | |
| def optical_field(program: str, s: dict[str, Any], cols: int = 24, rows: int = 14) -> list[list[float]]: | |
| sc = scale_analog(program, s) | |
| field: list[list[float]] = [] | |
| for r in range(rows): | |
| row: list[float] = [] | |
| for c in range(cols): | |
| ao = 0.35 + 0.45 * (sc["z"]) | |
| ar = 0.40 + 0.35 * abs(sc["x"]) | |
| obj_p = (c / cols) * math.tau + sc["y"] * 1.4 + float(s.get("t", 0)) * 0.7 | |
| ref_p = (r / rows) * math.tau + sc["z"] * 2.2 | |
| row.append(optical_interfere(ao, obj_p, ar, ref_p)) | |
| field.append(row) | |
| return field | |
| def ouroboros_tax(amplitude: float, bars: int = 8) -> float: | |
| bars = max(1, min(int(bars), 64)) | |
| return max(0.0, float(amplitude) * math.exp(-bars / 8.0)) | |
| def organs_eval(payload: dict) -> dict: | |
| # Hologram does not run the SZL kernel. Fail-closed — never fabricate LIVE. | |
| flags = {name: False for name in ORGANS} | |
| reason = "UNAVAILABLE — hologram has no kernel organs" | |
| if payload.get("fabricate_joule"): | |
| reason = "HARD_DENY — fabricated joule downs NERVOUS" | |
| return { | |
| "organs": flags, | |
| "live_count": 0, | |
| "blocked": True, | |
| "reason": reason, | |
| "energy": "UNAVAILABLE", | |
| "proven_trust": False, | |
| "uniqueness": "Conjecture 1", | |
| } | |
| def analog_payload(data: dict) -> dict: | |
| program = str(data.get("program") or "lorenz") | |
| if program not in PROGRAMS: | |
| program = "lorenz" | |
| chaos = clamp01(float(data.get("chaos") if data.get("chaos") is not None else 0.45)) | |
| drive = clamp01(float(data.get("drive") if data.get("drive") is not None else 0.55)) | |
| dt = float(data.get("dt") or 0.016) | |
| steps = int(data.get("steps") or (180 if program == "nemo" else 480)) | |
| seed = seed_analog(program) | |
| state = { | |
| "x": float(data["x"]) if data.get("x") is not None else seed["x"], | |
| "y": float(data["y"]) if data.get("y") is not None else seed["y"], | |
| "z": float(data["z"]) if data.get("z") is not None else seed["z"], | |
| "t": float(data["t"]) if data.get("t") is not None else 0.0, | |
| } | |
| if program == "nemo": | |
| bank = data.get("bank") | |
| state["bank"] = pad_nemo_bank(bank) | |
| trail, last = analog_trail(program, state, steps, chaos, drive, dt) | |
| sc = scale_analog(program, last) | |
| ao = max(0.0, 0.5 + 0.5 * math.hypot(sc["x"], sc["y"])) | |
| ar = max(0.0, 0.35 + 0.55 * sc["z"]) | |
| dphi = math.atan2(sc["y"], sc["x"] + 1e-9) | |
| intensity = optical_interfere(ao, dphi, ar, 0.0) | |
| recon = optical_reconstruct(intensity, dphi) | |
| pots = analog_coefficients(chaos, program) | |
| corr = 0.0 | |
| schmitt = 1.0 | |
| for xyz in trail: | |
| tmp = {"x": float(xyz[0]), "y": float(xyz[1]), "z": float(xyz[2]), "t": 0.0} | |
| sci = scale_analog(program, tmp) | |
| corr = analog_correlate(sci["x"], sci["y"], corr, dt) | |
| schmitt = analog_schmitt(sci["x"], schmitt) | |
| ckt = analog_circuit(sc["x"], sc["y"], sc["z"], corr) | |
| ckt["cmp"] = schmitt | |
| out: dict[str, Any] = { | |
| "program": program, | |
| "label": PROGRAM_LABELS[program], | |
| "trail": trail[-180:], | |
| "last": [last["x"], last["y"], last["z"]], | |
| "t": last["t"], | |
| "scale": sc, | |
| "pots": pots, | |
| "holo": intensity, | |
| "recon": recon, | |
| "circuit": ckt, | |
| "jack": analog_jack(ckt, recon, drive), | |
| "field": optical_field(program, last), | |
| "honesty": "MEASURED", | |
| "energy": "UNAVAILABLE", | |
| "uniqueness": "Conjecture 1", | |
| "proven_trust": False, | |
| } | |
| if "bank" in last: | |
| out["bank"] = last["bank"] | |
| return out | |
| class Handler(BaseHTTPRequestHandler): | |
| def log_message(self, fmt: str, *args) -> None: | |
| return | |
| def _send(self, code: int, body: bytes, ctype: str) -> None: | |
| self.send_response(code) | |
| self.send_header("Content-Type", ctype) | |
| self.send_header("Content-Length", str(len(body))) | |
| self.send_header("Cache-Control", "no-store") | |
| self.end_headers() | |
| self.wfile.write(body) | |
| def _json(self, code: int, payload: dict) -> None: | |
| self._send(code, json.dumps(payload).encode(), "application/json") | |
| def _read(self) -> dict: | |
| n = int(self.headers.get("Content-Length") or 0) | |
| raw = self.rfile.read(n) if n else b"{}" | |
| try: | |
| data = json.loads(raw.decode()) | |
| return data if isinstance(data, dict) else {} | |
| except Exception: | |
| return {} | |
| def do_GET(self) -> None: # noqa: N802 | |
| path = urlparse(self.path).path | |
| if path in ("/", "/index.html"): | |
| body = HTML.read_bytes() if HTML.is_file() else b"<h1>NEXUS</h1>" | |
| self._send(200, body, "text/html; charset=utf-8") | |
| return | |
| if path in ("/health", "/healthz"): | |
| self._json( | |
| 200, | |
| { | |
| "ok": True, | |
| "space": "nexus", | |
| "kernel": "hologram", | |
| "analog": "AdEx 5-organ anatomy + WILLAY second brain + analog correlator + hybrid IC + analog circuits + 3F STDP", | |
| "programs": list(PROGRAMS), | |
| "uniqueness": "Conjecture 1", | |
| "energy": "UNAVAILABLE", | |
| "proven_trust": False, | |
| "github": "szl-holdings/nexus", | |
| }, | |
| ) | |
| return | |
| self._send(404, b"not found", "text/plain") | |
| def do_POST(self) -> None: # noqa: N802 | |
| path = urlparse(self.path).path | |
| data = self._read() | |
| if path == "/api/lambda": | |
| axes = [float(x) for x in (data.get("axes") or list(YUYAY_FLOORS))] | |
| try: | |
| value = lambda_aggregate(axes) | |
| sacred = len(axes) >= 2 and (axes[0] < 0.95 or axes[1] < 0.95) | |
| blocked = sacred or value == 0.0 | |
| self._json( | |
| 200, | |
| { | |
| "lambda": value, | |
| "blocked": blocked, | |
| "decision": "BLOCKED" if blocked else "ADMITTED", | |
| "uniqueness": "Conjecture 1", | |
| "honesty": "MEASURED", | |
| "proven_trust": False, | |
| "energy": "UNAVAILABLE", | |
| }, | |
| ) | |
| except Exception as exc: | |
| self._json(400, {"error": str(exc), "honesty": "MEASURED"}) | |
| return | |
| if path == "/api/analog": | |
| try: | |
| self._json(200, analog_payload(data)) | |
| except Exception as exc: | |
| self._json(400, {"error": str(exc), "honesty": "MEASURED", "energy": "UNAVAILABLE"}) | |
| return | |
| if path == "/api/lorenz": | |
| x = float(data.get("x") or 0.1) | |
| y = float(data.get("y") or 0.0) | |
| z = float(data.get("z") or 0.0) | |
| steps = int(data.get("steps") or 400) | |
| trail = lorenz_rk4(x, y, z, steps) | |
| self._json( | |
| 200, | |
| { | |
| "trail": trail[-180:], | |
| "last": trail[-1], | |
| "sigma": SIGMA, | |
| "rho": RHO, | |
| "beta": BETA, | |
| "honesty": "MEASURED", | |
| "energy": "UNAVAILABLE", | |
| }, | |
| ) | |
| return | |
| if path == "/api/organs": | |
| self._json(200, organs_eval(data)) | |
| return | |
| if path == "/api/ouroboros": | |
| tax = ouroboros_tax(float(data.get("amplitude") or 1.0), int(data.get("bars") or 8)) | |
| self._json( | |
| 200, | |
| { | |
| "tax": tax, | |
| "bars": int(data.get("bars") or 8), | |
| "energy": "UNAVAILABLE", | |
| "uniqueness": "Conjecture 1", | |
| }, | |
| ) | |
| return | |
| self._send(404, b"not found", "text/plain") | |
| def selftest() -> None: | |
| # Harmonic oscillator changes sign. | |
| s = seed_analog("harmonic") | |
| saw_neg = False | |
| for _ in range(400): | |
| s = analog_step("harmonic", s, 0.02, 0.0, 0.5) | |
| if s["x"] < 0: | |
| saw_neg = True | |
| break | |
| assert saw_neg, "harmonic never crossed zero" | |
| # Lotka stays positive. | |
| s = seed_analog("lotka") | |
| for _ in range(240): | |
| s = analog_step("lotka", s, 0.02, 0.4, 0.5) | |
| assert s["x"] > 0 and s["y"] > 0, "lotka left the first quadrant" | |
| # NEMO spikes under drive. | |
| s = seed_analog("nemo") | |
| spiked = False | |
| for _ in range(80): | |
| s = analog_step("nemo", s, 0.016, 0.45, 1.0) | |
| if s["z"] > 0.12: | |
| spiked = True | |
| break | |
| if any(v > 20 for v in (s.get("bank") or [])[:5]): | |
| spiked = True | |
| break | |
| assert spiked, "NEMO did not spike under drive" | |
| # Synaptic leak: a loaded trace decays with no spikes if drive is off and v held subthreshold. | |
| s = seed_analog("nemo") | |
| s["bank"][10] = 12.0 | |
| s["bank"][0] = -80.0 | |
| before = s["bank"][10] | |
| for _ in range(40): | |
| s = analog_step("nemo", s, 0.016, 0.0, 0.0) | |
| assert s["bank"][10] < before, "NEMO synapse did not leak" | |
| # Optical constructive / destructive. | |
| plus = optical_interfere(1, 0, 1, 0) | |
| minus = optical_interfere(1, 0, 1, math.pi) | |
| assert abs(plus - 4.0) < 1e-9, plus | |
| assert abs(minus - 0.0) < 1e-9, minus | |
| # Programs enumerate. | |
| assert len(PROGRAMS) == 6 | |
| # 15-cell persist pads; optical STDP leaks toward 1 without spikes. | |
| s = seed_analog("nemo") | |
| s["bank"] = s["bank"][:15] | |
| s = analog_step("nemo", s, 0.016, 0.0, 0.0) | |
| assert len(s["bank"]) == 20, len(s["bank"]) | |
| s["bank"][15:20] = [2.4] * 5 | |
| s["bank"][0] = -80.0 | |
| for _ in range(40): | |
| s = analog_step("nemo", s, 0.016, 0.0, 0.0) | |
| assert all(0.05 < w < 2.4 for w in s["bank"][15:20]), s["bank"][15:20] | |
| # Organs fail-closed on the hologram. | |
| org = organs_eval({}) | |
| assert org["live_count"] == 0 and org["blocked"] is True | |
| ckt = analog_circuit(0.5, -0.4, 0.2) | |
| assert abs(ckt["mul"] - -0.2) < 1e-9 | |
| assert analog_circuit(-0.2, 0, 0)["cmp"] == -1.0 | |
| assert ckt["corr"] == 0.0 | |
| c = 0.0 | |
| for _ in range(80): | |
| c = analog_correlate(0.8, 0.5, c, 0.02, 0.12) | |
| assert c > 0.3 | |
| assert analog_schmitt(-0.04, 1.0) == 1.0 | |
| assert analog_schmitt(-0.2, 1.0) == -1.0 | |
| driven = analog_jack(analog_circuit(0.5, 0, 0, 0.8), 0, 1) | |
| quiet = analog_jack(analog_circuit(0.5, 0, 0, 0.8), 0, 0) | |
| assert driven > quiet | |
| print("analog selftest ok — AdEx 5ORG, WILLAY 2BRN, analog correlator, hybrid IC, analog circuits, 3F STDP, optical (Ao+Ar)²", flush=True) | |
| def main() -> None: | |
| if "--selftest" in sys.argv: | |
| selftest() | |
| return | |
| port = int(os.environ.get("PORT", "7860")) | |
| httpd = ThreadingHTTPServer(("0.0.0.0", port), Handler) | |
| print(f"nexus hologram listening 0.0.0.0:{port}", flush=True) | |
| httpd.serve_forever() | |
| if __name__ == "__main__": | |
| main() | |