#!/usr/bin/env python3 """Reproduce a FINITE CYCLIC analogue of the manuscript's STFT obstruction. This numerical experiment does not prove the infinite-dimensional theorem. Its complete finite measurement grid is Z_N x Z_N, using a unitary DFT. Only NumPy and matplotlib are required. Run: python3 verify.py Outputs: verification.json, verification_figure.png, verification_figure.pdf. """ from __future__ import annotations import json from pathlib import Path import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import numpy as np def stft(f: np.ndarray, window: np.ndarray) -> np.ndarray: """Rows are all cyclic shifts; columns are all unitary-DFT frequencies.""" return np.array([ np.fft.fft(f * np.conjugate(np.roll(window, shift)), norm="ortho") for shift in range(len(f)) ]) def quotient_distance(x: np.ndarray, y: np.ndarray) -> float: """min_{|alpha|=1} ||x - alpha*y||_2, with stable direct subtraction.""" inner = np.vdot(y, x) alpha = inner / abs(inner) if abs(inner) else 1.0 + 0.0j return float(np.linalg.norm(x - alpha * y)) def main() -> None: out = Path(__file__).resolve().parent n_samples, bandwidth, rho, seed = 256, 12, 0.82, 20261115 n = np.arange(n_samples) spectrum_q = np.zeros(n_samples, dtype=complex) spectrum_q[:bandwidth] = rho ** np.arange(bandwidth) q = np.fft.ifft(spectrum_q, norm="ortho") g = np.abs(q) ** 2 g /= np.linalg.norm(g) alternating = (-1.0) ** n f_plus = g * (1.0 + 0.5 * alternating) / np.sqrt(1.25) f_minus = g * (1.0 - 0.5 * alternating) / np.sqrt(1.25) v_plus, v_minus = stft(f_plus, g), stft(f_minus, g) mag_plus, mag_minus = np.abs(v_plus), np.abs(v_minus) mag_difference = np.abs(mag_plus - mag_minus) v_first, v_second = stft(g, g), stft(alternating * g, g) centered_frequencies = np.fft.fftfreq(n_samples) * n_samples outside_g_support = np.abs(centered_frequencies) > bandwidth - 1 spectrum_g = np.fft.fft(g, norm="ortho") tol = 1e-12 expected_distance = 2.0 / np.sqrt(5.0) # Three spectral sectors, each a modulation of the same normalized window. # Their windowed Fourier supports are disjoint on the complete finite grid. sectors_count = 3 centers = np.array([0, 85, 170]) basis = np.array([ g * np.exp(2j * np.pi * center * n / n_samples) for center in centers ]) gram = basis.conjugate() @ basis.T fourier_mixtures = np.array([ np.exp(2j * np.pi * r * np.arange(sectors_count) / sectors_count) @ basis / np.sqrt(sectors_count) for r in range(sectors_count) ]) mixture_gram = fourier_mixtures.conjugate() @ fourier_mixtures.T mixture_data = np.array([np.abs(stft(f, g)) for f in fourier_mixtures]) sector_data_discrepancy = max( float(np.max(np.abs(y - mixture_data[0]))) for y in mixture_data ) # Tree bridge measurements repair the relative phases on this known orbit. phases = np.array([0.37, -1.14, 2.02]) coefficients = np.exp(1j * phases) / np.sqrt(sectors_count) bridge_edges = [(0, 1), (1, 2)] recovered = np.zeros(sectors_count, dtype=complex) recovered[0] = abs(coefficients[0]) bridge_records = [] for i, j in bridge_edges: y_real = float(abs(coefficients[i] + coefficients[j]) ** 2) y_imag = float(abs(coefficients[i] + 1j * coefficients[j]) ** 2) diagonal_sum = float(abs(coefficients[i]) ** 2 + abs(coefficients[j]) ** 2) correlation = (y_real - diagonal_sum) / 2 + 1j * (y_imag - diagonal_sum) / 2 recovered[j] = np.conjugate(correlation / recovered[i]) bridge_records.append({ "edge": [i, j], "intensity_plus": y_real, "intensity_plus_i": y_imag, "correlation_real": float(correlation.real), "correlation_imag": float(correlation.imag), }) bridge_error = quotient_distance(recovered, coefficients) # The raw perturbation has exactly the requested l2 size. For the normalized # window, use the ACTUAL perturbation size in the theorem, not the nominal one. rng = np.random.default_rng(seed) direction = rng.standard_normal(n_samples) + 1j * rng.standard_normal(n_samples) direction /= np.linalg.norm(direction) perturbations = [] for epsilon in [1e-6, 1e-4, 1e-2, 1e-1]: raw_window = g + epsilon * direction for mode in ["raw", "normalized"]: window = raw_window if mode == "raw" else raw_window / np.linalg.norm(raw_window) delta = float(np.linalg.norm(window - g)) plus = np.abs(stft(f_plus, window)) minus = np.abs(stft(f_minus, window)) distance = float(np.linalg.norm(plus - minus)) intensity_distance = float(np.linalg.norm(plus ** 2 - minus ** 2)) orbit_to_common = max( float(np.linalg.norm(np.abs(stft(f, window)) - mixture_data[0])) for f in fourier_mixtures ) perturbations.append({ "mode": mode, "nominal_epsilon": epsilon, "actual_window_change_l2": delta, "window_l2_norm": float(np.linalg.norm(window)), "pair_amplitude_data_l2_distance": distance, "pair_amplitude_bound": 2.0 * delta, "pair_intensity_data_l2_distance": intensity_distance, "pair_intensity_bound": 4.0 * delta + 2.0 * delta ** 2, "three_sector_max_distance_to_common_baseline": orbit_to_common, "three_sector_common_baseline_bound": delta, "bounds_pass": bool( distance <= 2.0 * delta + tol and intensity_distance <= 4.0 * delta + 2.0 * delta ** 2 + tol and orbit_to_common <= delta + tol ), }) values = { "window_minimum": float(np.min(g)), "window_l2_norm": float(np.linalg.norm(g)), "f_plus_minimum": float(np.min(f_plus)), "f_minus_minimum": float(np.min(f_minus)), "f_plus_l2_norm": float(np.linalg.norm(f_plus)), "f_minus_l2_norm": float(np.linalg.norm(f_minus)), "f_plus_minus_inner_product": float(np.vdot(f_plus, f_minus).real), "signal_quotient_distance": quotient_distance(f_plus, f_minus), "predicted_signal_quotient_distance": float(expected_distance), "max_amplitude_data_difference": float(np.max(mag_difference)), "amplitude_data_l2_difference": float(np.linalg.norm(mag_difference)), "max_intensity_data_difference": float(np.max(np.abs(mag_plus ** 2 - mag_minus ** 2))), "moyal_sum_plus": float(np.sum(mag_plus ** 2)), "max_component_crossproduct": float(np.max(np.abs(v_first * np.conjugate(v_second)))), "max_window_spectrum_outside_proved_support": float(np.max(np.abs(spectrum_g[outside_g_support]))), "three_sector_basis_gram_error": float(np.max(np.abs(gram - np.eye(sectors_count)))), "three_sector_mixture_gram_error": float(np.max(np.abs(mixture_gram - np.eye(sectors_count)))), "three_sector_max_amplitude_data_difference": sector_data_discrepancy, "bridge_reconstruction_error_mod_global_phase": bridge_error, } checks = { "window_strictly_positive_at_every_cyclic_sample": bool(np.all(g > 0)), "both_signals_strictly_positive_at_every_cyclic_sample": bool(np.all(f_plus > 0) and np.all(f_minus > 0)), "all_norms_correct": bool(max(abs(np.linalg.norm(f) - 1) for f in [g, f_plus, f_minus]) < tol), "quotient_distance_correct": abs(values["signal_quotient_distance"] - expected_distance) < tol, "full_spectrogram_equality_to_numerical_tolerance": values["max_amplitude_data_difference"] < tol, "component_crossproducts_zero_to_numerical_tolerance": values["max_component_crossproduct"] < tol, "finite_moyal_identity": abs(values["moyal_sum_plus"] - 1.0) < tol, "proved_fourier_support_matches": values["max_window_spectrum_outside_proved_support"] < tol, "three_sector_orbit_verifies": bool(sector_data_discrepancy < tol and values["three_sector_mixture_gram_error"] < tol), "tree_bridge_reconstruction_verifies": bridge_error < tol, "all_perturbation_bounds_verify": all(p["bounds_pass"] for p in perturbations), } checks = {name: bool(passed) for name, passed in checks.items()} result = { "scope": "Finite cyclic analogue on Z_256; numerical reproduction, not the infinite-dimensional proof.", "parameters": {"N": n_samples, "L": bandwidth, "rho": rho, "random_seed": seed, "absolute_tolerance": tol}, "normalization": "Unitary DFT; sum over the complete shift-frequency grid of |V_g f|^2 equals ||g||_2^2 ||f||_2^2.", "construction": "Q[r]=rho^r for 0<=r