#!/usr/bin/env python3 """ELYSIAEN final: endpoint-safe local attenuation from one frozen Green capsule. Standalone: no earlier ELYSIAEN files are imported. Requires Python 3.10+, numpy, scipy and matplotlib. Run `python v4_engine.py`; `--quick` reduces the randomized suite. This is a CPU finite-model correctness experiment, not an optical-device, commercial-game-engine, energy or frame-rate benchmark. Models: T_D = D_full T0 D_full, 0 <= D_full <= I diagonal; and the more general fixed-interface local block [[B, Lin*T_ZR], [T_RZ*Rout, T_RR]]. These update a declared finite state basis. Scene-to-transport compilation, new reflective surfaces and new scattering directions are not demonstrated. """ from __future__ import annotations import os # Keep this small reproducible experiment from oversubscribing BLAS threads. os.environ["OPENBLAS_NUM_THREADS"] = "1" os.environ["OMP_NUM_THREADS"] = "1" os.environ["MKL_NUM_THREADS"] = "1" import argparse import json import platform from pathlib import Path import numpy as np import scipy from scipy.linalg import solve SEED = 20261025 def frozen_capsule(green, indices): """Compile a return matrix and harmonic lift using k coordinate columns. All acquisition/storage below is explicit numerical array access here. An optical device would have to acquire and validate these responses. """ z = np.asarray(indices, dtype=int) columns = green[:, z] principal = columns[z] inverse = solve(principal, np.eye(len(z))) lift = columns @ inverse return {"indices": z, "inverse": inverse, "return": np.eye(len(z))-inverse, "lift": lift, "principal": principal} def capsule_response(capsule, source, reference_response, attenuation): """Exact T_D response; finite at all-transparent and all-opaque endpoints. S=I-K^-1, L=G[:,Z]K^-1; u is the actual state on the edited coordinates. (I-D S D)u=(I-D)b_Z + D K^-1 q_Z. x=q + L(Du-q_Z) + E(I-D)u. No inverse attenuation or infinite penalty is formed. """ z = capsule["indices"] d = np.asarray(attenuation, dtype=float) if d.shape != (len(z),) or np.any(d < 0) or np.any(d > 1): raise ValueError("attenuation must have k entries in [0,1]") small = np.eye(len(z)) - d[:, None]*capsule["return"]*d[None, :] rhs = (1-d[:, None])*source[z] + d[:, None]*(capsule["inverse"]@reference_response[z]) boundary = solve(small, rhs) answer = reference_response + capsule["lift"]@(d[:, None]*boundary-reference_response[z]) answer[z] += (1-d[:, None])*boundary return answer, boundary, small def material_response(capsule, t0, source, reference_response, local, incoming, outgoing): """Compile arbitrary admitted local nonnegative mixing behind the same Z. Reordered as Z,R, the edited transport is [[local, incoming*T_ZR], [T_RZ*outgoing, T_RR]]. The entire nonlocal return is cached: J=T_ZR*(I-T_RR)^-1*T_RZ. Stability must be checked for C=local+incoming*J*outgoing. """ z = capsule["indices"] external_return = capsule["return"]-t0[np.ix_(z, z)] lift = capsule["lift"].copy() lift[z] -= np.eye(len(z)) forcing = capsule["inverse"]@reference_response[z]-source[z] reduced_return = local+incoming@external_return@outgoing small = np.eye(len(z))-reduced_return boundary = solve(small, source[z]+incoming@forcing) answer = reference_response+lift@(outgoing@boundary-reference_response[z]) answer[z] = boundary return answer, reduced_return, small def weighted_infinity(matrix, row_weight, column_weight=None): if column_weight is None: column_weight = row_weight return float(np.max(np.sum(np.abs(matrix)*column_weight[None, :], axis=1)/row_weight)) def world_index(x, y): return (x//10)*100 + y*10 + x%10 def tile_world(): adjacency = np.zeros((200, 200)) for y in range(10): for x in range(20): for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)): xx, yy = x+dx, y+dy if not (0 <= xx < 20 and 0 <= yy < 10): continue if (x < 10) != (xx < 10) and y not in (3, 4, 5, 6): continue adjacency[world_index(x, y), world_index(xx, yy)] = 1 return .72*adjacency/4 def obstacle(pose): x, y = pose return np.asarray([world_index(xx, yy) for yy in range(y, y+3) for xx in range(x, x+2)], dtype=int) def sources_for_pose(indices): base = np.full((200, 3), .004) for x, y, rgb in [(2, 2, [1.6, .25, .04]), (3, 2, [1.6, .25, .04]), (16, 7, [.04, .85, 1.7]), (16, 8, [.04, .85, 1.7])]: base[world_index(x, y)] += rgb warm = base*np.asarray([.37, 1.2, .65]) local = base.copy() local[world_index(8, 1)] += [.18, .4, .23] energized = base.copy() energized[indices] += (1+np.arange(len(indices))[:, None]/10)*np.asarray([.29, .31, .37]) return np.concatenate([base, warm, local, energized], axis=1) def scene_suite(): t0 = tile_world() green = solve(np.eye(200)-t0, np.eye(200)) rng = np.random.default_rng(SEED) patterns = [("opaque", np.zeros(6)), ("transparent", np.ones(6)), ("uniform_020", np.full(6, .2)), ("uniform_060", np.full(6, .6)), ("mixed_endpoints", np.asarray([0, .25, .5, .75, 1., 0.])), ("random_interior", rng.uniform(.05, .95, 6))] cache = set() records = [] selected = None max_error = 0. max_condition = 0. for pose in [(x, 4) for x in range(5, 17)]: z = obstacle(pose) misses = [int(j) for j in z if int(j) not in cache] cache.update(map(int, z)) capsule = frozen_capsule(green, z) source = sources_for_pose(z) reference = green@source min_lift = float(np.min(capsule["lift"])) lift_norm = weighted_infinity(capsule["lift"], np.ones(200), np.ones(6)) return_norm = weighted_infinity(capsule["return"], np.ones(6)) assert min_lift >= -1e-12 and lift_norm <= 1+1e-12 and return_norm <= .72+1e-12 for name, d in patterns: full_d = np.ones(200) full_d[z] = d actual_t = full_d[:, None]*t0*full_d[None, :] truth = solve(np.eye(200)-actual_t, source) answer, boundary, small = capsule_response(capsule, source, reference, d) error = float(np.max(np.abs(answer-truth))) condition = float(np.linalg.cond(small, np.inf)) assert error < 2e-11 assert condition <= (1+.72)/(1-.72)+1e-11 assert np.max(np.abs(answer[z]-boundary)) < 1e-12 max_error = max(max_error, error) max_condition = max(max_condition, condition) record = {"pose": list(pose), "attenuation_pattern": name, "attenuation": d.tolist(), "coordinate_ports": 6, "RGB_source_families": 4, "scalar_source_RHS": 12, "max_abs_RGB_coefficient_error": error, "small_system_condition_infinity": condition, "lift_weighted_infinity_norm": lift_norm, "return_weighted_infinity_norm": return_norm, "new_coordinate_columns_at_pose": len(misses) if name == "opaque" else 0, "new_value_dependent_columns": 0, "local_output_coordinates": 6} records.append(record) if pose == (9, 4) and name == "mixed_endpoints": selected = {"pose": pose, "attenuation": d, "reference": reference[:, 9:12], "truth": truth[:, 9:12], "answer": answer[:, 9:12]} return {"transport_states": 200, "reference_rho": .72, "poses": 12, "attenuation_patterns_per_pose": 6, "RGB_source_families": 4, "RGB_world_states_checked": len(records)*4, "scalar_RHS_checked": len(records)*12, "maximum_absolute_RGB_error": max_error, "maximum_small_system_condition_infinity": max_condition, "uniform_small_system_condition_bound": (1+.72)/(1-.72), "response_work": {"unique_coordinate_columns": len(cache), "coordinate_columns_in_current_capsule": 6, "warm_attenuation_changes_requiring_new_coordinate_columns": 0, "value_dependent_columns": 0, "source_queries_per_pose_scalar_RHS": 12, "source_queries_total_scalar_RHS": 12*12, "source_queries_reused_across_attenuation_patterns": True, "full_RGB_coefficients_reconstructed_per_world_state": 200*3, "prototype_reference_storage_coefficients": 200*200, "prototype_computes_full_reference_inverse": True, "prototype_reassembles_capsule_from_dense_reference_each_pose": True, "scope": "Logical cache/acquisition counters, not optical measurements. Columns, source projection, small solves, calibration, and full output have costs."}, "records": records}, selected def material_suite(): """Changing local scatter/routing matrices with a fixed six-port capsule.""" t0 = tile_world() green = solve(np.eye(200)-t0, np.eye(200)) rng = np.random.default_rng(SEED+3) records = [] selected = None for pose in [(x, 4) for x in range(5, 17)]: z = obstacle(pose) r = np.asarray([j for j in range(200) if j not in set(z)], dtype=int) capsule = frozen_capsule(green, z) source = sources_for_pose(z) q = green@source p = np.roll(np.eye(6), 1, axis=0) h = np.eye(6)[::-1] random_mix = [] for _ in range(3): m = rng.uniform(.1, 1, (6, 6)) random_mix.append(m/m.sum(axis=1)[:, None]) configs = [("reference", t0[np.ix_(z, z)], np.eye(6), np.eye(6)), ("noncommuting_routes", .04*np.eye(6)+.08*p, .7*p+.1*np.eye(6), .6*h+.2*np.eye(6)), ("dense_local_mixing", .15*random_mix[0], .8*random_mix[1], .9*random_mix[2])] for name, local, incoming, outgoing in configs: edited = t0.copy() edited[np.ix_(z, z)] = local edited[np.ix_(z, r)] = incoming@t0[np.ix_(z, r)] edited[np.ix_(r, z)] = t0[np.ix_(r, z)]@outgoing truth = solve(np.eye(200)-edited, source) answer, reduced, small = material_response(capsule, t0, source, q, local, incoming, outgoing) actual_rho = float(np.max(np.abs(np.linalg.eigvals(edited)))) reduced_rho = float(np.max(np.abs(np.linalg.eigvals(reduced)))) error = float(np.max(np.abs(answer-truth))) assert error < 2e-11 and actual_rho < 1 and reduced_rho < 1 assert np.all(edited >= 0) and np.min(reduced) >= -1e-12 records.append({"pose": list(pose), "configuration": name, "coordinate_ports": 6, "RGB_source_families": 4, "local_matrix_commutator_norm": float(np.linalg.norm(local@incoming-incoming@local, ord=np.inf)), "incoming_outgoing_commutator_norm": float(np.linalg.norm(incoming@outgoing-outgoing@incoming, ord=np.inf)), "full_transport_spectral_radius": actual_rho, "small_return_spectral_radius": reduced_rho, "small_system_condition_infinity": float(np.linalg.cond(small, np.inf)), "maximum_RGB_coefficient_error": error, "new_coordinate_columns_after_capsule_acquisition": 0, "new_value_dependent_columns": 0}) if pose == (9, 4) and name == "dense_local_mixing": selected = {"pose": pose, "attenuation": None, "reference": q[:, 9:12], "truth": truth[:, 9:12], "answer": answer[:, 9:12]} return {"poses": 12, "local_configurations_per_pose": 3, "RGB_source_families": 4, "RGB_world_states_checked": len(records)*4, "maximum_absolute_RGB_error": max(a["maximum_RGB_coefficient_error"] for a in records), "scope": "Local internal B and incoming/outgoing mixing L,R vary behind a fixed six-coordinate interface; existing exterior transport remains fixed. Physical scene-to-matrix compilation is not demonstrated.", "records": records}, selected def randomized_suite(count): rng = np.random.default_rng(SEED+1) rows = [] for trial in range(count): n = (16, 32, 64)[trial % 3] rho = (.2, .7, .95, .999)[trial % 4] weight = np.exp(rng.uniform(-1.3, 1.3, n)) base = rng.uniform(0, 1, (n, n)) base *= rng.uniform(size=(n, n)) < .3 base += np.eye(n)*.2 base *= rho/base.sum(axis=1)[:, None] t0 = weight[:, None]*base/weight[None, :] green = solve(np.eye(n)-t0, np.eye(n)) k = int(rng.integers(1, min(12, n)+1)) z = rng.choice(n, k, replace=False) capsule = frozen_capsule(green, z) d = rng.uniform(0, 1, k) d[::3] = 0. d[1::4] = 1. source = rng.uniform(0, 1, (n, 3))*weight[:, None] reference = green@source full_d = np.ones(n) full_d[z] = d truth = solve(np.eye(n)-full_d[:, None]*t0*full_d[None, :], source) answer, boundary, small = capsule_response(capsule, source, reference, d) error = float(np.max(np.abs(answer-truth)/weight[:, None])) relative_error = error/float(np.max(np.abs(truth)/weight[:, None])) lift_norm = weighted_infinity(capsule["lift"], weight, weight[z]) return_norm = weighted_infinity(capsule["return"], weight[z]) condition = weighted_infinity(small, weight[z])*weighted_infinity(solve(small, np.eye(k)), weight[z]) min_lift = float(np.min(capsule["lift"])) min_return = float(np.min(capsule["return"])) assert min_lift >= -2e-10 and min_return >= -2e-10 assert error < 2e-9 and lift_norm <= 1+2e-10 and return_norm <= rho+2e-10 assert condition <= (1+rho)/(1-rho)+2e-8 # Opaque occupancy: a residual at the coordinates has a harmonic lift # with gain <=1. Check this independently of source response accuracy. qz = reference[z] theta = solve(capsule["principal"], qz) perturbation = rng.normal(size=(k, 3))*weight[z, None]*1e-5 candidate = theta+perturbation residual = capsule["principal"]@candidate-qz exact_opaque = reference-capsule["lift"]@qz exact_opaque[z] += source[z] approximate = reference-green[:, z]@candidate approximate[z] += source[z] actual = float(np.max(np.abs(approximate-exact_opaque)/weight[:, None])) bound = float(np.max(np.abs(residual)/weight[z, None])) assert actual <= bound+2e-10 rows.append({"n": n, "k": k, "rho": rho, "weighted_absolute_response_error": error, "relative_weighted_response_error": relative_error, "minimum_lift_entry": min_lift, "minimum_return_entry": min_return, "lift_weighted_infinity_norm": lift_norm, "return_weighted_infinity_norm": return_norm, "small_system_weighted_condition": condition, "small_system_condition_bound": (1+rho)/(1-rho), "occupancy_residual_error": actual, "occupancy_residual_certificate": bound}) return {"cases": count, "response_failures": 0, "passivity_failures": 0, "occupancy_residual_certificate_violations": 0, "occupancy_residual_check_absolute_tolerance": 2e-10, "maximum_positive_floating_point_certificate_excess": max(0., max(r["occupancy_residual_error"]-r["occupancy_residual_certificate"] for r in rows)), "certificate_check_scope": "Double-precision checks within the declared tolerance; the theorem is exact but these numerical evaluations are not outward-rounded certificates.", "maximum_weighted_response_error": max(r["weighted_absolute_response_error"] for r in rows), "maximum_relative_weighted_response_error": max(r["relative_weighted_response_error"] for r in rows), "maximum_lift_weighted_norm": max(r["lift_weighted_infinity_norm"] for r in rows), "maximum_residual_error_to_bound": max(r["occupancy_residual_error"]/r["occupancy_residual_certificate"] for r in rows), "records": rows} def endpoint_controls(): # A one-state near-conservative world disproves a rho-independent bound # for residuals of the partial-attenuation boundary equation itself. values = [] for rho in (.9, .99, .999, .9999): gain = 1/(1-rho) values.append({"rho": rho, "transparent_boundary_residual_gain": gain, "occupancy_harmonic_lift_residual_gain": 1.}) # Incorrectly treating a partial mask as a binary opaque obstacle fails. t0 = np.asarray([[0, .6], [.6, 0]]) b = np.asarray([[1.], [.2]]) green = solve(np.eye(2)-t0, np.eye(2)) capsule = frozen_capsule(green, [0]) q = green@b good, _, _ = capsule_response(capsule, b, q, [.5]) binary, _, _ = capsule_response(capsule, b, q, [0.]) return {"near_conservative_boundary_residual_control": values, "partial_mask_misclassified_as_opaque_maximum_error": float(np.max(np.abs(good-binary))), "source_convention": "An opaque isolated coordinate retains its local numerical source x_Z=b_Z. Mask b_Z to zero when the physical renderer requires a dark occupied coordinate."} def stability_suite(count): rng = np.random.default_rng(SEED+4) cases = [] for trial in range(count): n, k = 24, 5 t0 = rng.uniform(.1, 1, (n, n)) t0 *= .6/t0.sum(axis=1)[:, None] green = solve(np.eye(n)-t0, np.eye(n)) z = rng.choice(n, k, replace=False) r = np.asarray([i for i in range(n) if i not in set(z)]) capsule = frozen_capsule(green, z) m = rng.uniform(0, 1, (k, k)); m /= m.sum(axis=1)[:, None] h = rng.uniform(0, 1, (k, k)); h /= h.sum(axis=1)[:, None] incoming = .8*m outgoing = .8*h if trial % 2: local = 1.05*np.eye(k)+.01*m else: local = .1*m edited = t0.copy() edited[np.ix_(z, z)] = local edited[np.ix_(z, r)] = incoming@t0[np.ix_(z, r)] edited[np.ix_(r, z)] = t0[np.ix_(r, z)]@outgoing reduced = local+incoming@(capsule["return"]-t0[np.ix_(z, z)])@outgoing full_rho = float(np.max(np.abs(np.linalg.eigvals(edited)))) small_rho = float(np.max(np.abs(np.linalg.eigvals(reduced)))) assert (full_rho < 1) == (small_rho < 1) cases.append({"full_transport_spectral_radius": full_rho, "reduced_return_spectral_radius": small_rho, "stable": bool(full_rho < 1)}) return {"cases": count, "stable_cases": sum(r["stable"] for r in cases), "unstable_cases": sum(not r["stable"] for r in cases), "classification_discrepancies": 0, "scope": "Only the threshold relation rho(T')<1 iff rho(C)<1 is asserted. Spectral radii need not be numerically equal.", "records": cases} def image(values): return np.concatenate([values[:100].reshape(10, 10, -1), values[100:].reshape(10, 10, -1)], axis=1) def render(selected, scenes, materials, randoms, path): import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt from matplotlib.colors import LogNorm from matplotlib.patches import Rectangle plt.rcParams.update({"font.family": "DejaVu Sans", "font.size": 9}) fig, axes = plt.subplots(2, 2, figsize=(11.4, 7.2), layout="constrained") fig.patch.set_facecolor("#f4f7fc") for ax, key, title in zip(axes.flat[:3], ("reference", "truth", "answer"), ("Frozen reference | energized source in edited region", "Dense local scatter/routing | direct 200-state oracle", "Six-column capsule | local material and route update")): display = (1-np.exp(-3*np.maximum(image(selected[key]), 0)))**(1/2.2) ax.imshow(display, interpolation="nearest") ax.set_title(title, loc="left", color="#1b2846", fontsize=10, pad=10) x, y = selected["pose"] ax.add_patch(Rectangle((x-.5, y-.5), 2, 3, fc="none", ec="#d7bdff", lw=1.5)) ax.axvline(9.5, color="#cac0ee", ls="--", lw=.7) ax.set_xticks([]); ax.set_yticks([]) ax = axes.flat[3] error = np.max(np.abs(selected["truth"]-selected["answer"]), axis=1) im = ax.imshow(image(np.maximum(error, 1e-18)[:, None])[:, :, 0], cmap="magma", norm=LogNorm(1e-18, 1e-12), interpolation="nearest") ax.set_title(f"Absolute RGB coefficient error | max {error.max():.2e}", loc="left", color="#1b2846", fontsize=10, pad=10) ax.set_xticks([]); ax.set_yticks([]) fig.colorbar(im, ax=ax, fraction=.035, pad=.025, label="Maximum RGB coefficient error") for ax in axes.flat: for spine in ax.spines.values(): spine.set_visible(False) fig.suptitle("ELYSIAEN final | one frozen capsule, changing local worlds", x=.01, ha="left", fontsize=15, weight="bold", color="#182441") fig.supxlabel(f"{scenes['RGB_world_states_checked']} attenuation + {materials['RGB_world_states_checked']} material RGB states; {randoms['cases']} weighted tests. CPU correctness only; acquisition and output have costs.", fontsize=9, color="#596680") fig.savefig(path, dpi=190) plt.close(fig) def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--quick", action="store_true", help="Run 24 rather than 180 randomized cases") parser.add_argument("--output-prefix", default="v4_engine") args = parser.parse_args() prefix = Path(args.output_prefix) prefix.parent.mkdir(parents=True, exist_ok=True) scenes, selected = scene_suite() materials, selected_material = material_suite() randoms = randomized_suite(24 if args.quick else 180) stability = stability_suite(20 if args.quick else 120) result = {"title": "Lh//?∞ — ELYSIÆN — The Noctilucent Algebra of Self-Evolving Worlds", "edition": "Final standalone research experiment", "seed": SEED, "model": "T_D=D_full*T0*D_full with diagonal D in [0,1]; and fixed-interface local block [[B,Lin*T_ZR],[T_RZ*Rout,T_RR]]; unchanged finite state basis", "software": {"Python": platform.python_version(), "NumPy": np.__version__, "SciPy": scipy.__version__}, "scene_suite": scenes, "material_suite": materials, "randomized_suite": randoms, "stability_suite": stability, "negative_and_endpoint_controls": endpoint_controls(), "scope": "Exact finite transport identities and CPU checks. No optical hardware, game-engine deployment, timing, energy, historical-priority or T9 validation."} render(selected_material, scenes, materials, randoms, prefix.with_suffix(".png")) result_path = Path(str(prefix)+"_results.json") result_path.write_text(json.dumps(result, indent=2)+"\n", encoding="utf-8") print(json.dumps({"results": str(result_path), "figure": str(prefix.with_suffix('.png')), "RGB_world_states_checked": scenes["RGB_world_states_checked"], "maximum_absolute_RGB_error": scenes["maximum_absolute_RGB_error"], "material_RGB_states_checked": materials["RGB_world_states_checked"], "maximum_material_RGB_error": materials["maximum_absolute_RGB_error"], "stability_classifications": stability["cases"], "randomized_cases": randoms["cases"], "maximum_weighted_response_error": randoms["maximum_weighted_response_error"], "unique_coordinate_columns": scenes["response_work"]["unique_coordinate_columns"]}, indent=2)) if __name__ == "__main__": main()