Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
tensor-tomography
inverse-problems
positive-sensing
reproducible-research
Synthetic
| #!/usr/bin/env python3 | |
| """AËQIRION III: positive probe design and expressive-resource bounds. | |
| All algebraic inequalities, tensor contractions, Walsh identities, gain-graph | |
| ranks, and support-cover checks use exact Fraction/integer arithmetic. Optional | |
| NumPy eigensolver experiments illustrate the proven spectral formulas; their | |
| floating-point results are explicitly separated from exact verification. | |
| """ | |
| from __future__ import annotations | |
| from fractions import Fraction as F | |
| from itertools import product | |
| import json | |
| from math import sqrt | |
| from pathlib import Path | |
| import random | |
| def parity(x): | |
| return 1 if x.bit_count() % 2 == 0 else -1 | |
| def cube_edges(n): | |
| return [(x, x ^ (1 << i)) for x in range(1 << n) | |
| for i in range(n) if x < (x ^ (1 << i))] | |
| def dot(a, b): | |
| return sum((x * y for x, y in zip(a, b)), F(0)) | |
| def tensor(factors): | |
| out = [F(1)] | |
| for factor in factors: | |
| out = [a * b for a in out for b in factor] | |
| return out | |
| def apply_h0(n, x): | |
| out = [n * a for a in x] | |
| for u, v in cube_edges(n): | |
| out[u] += x[v] | |
| out[v] += x[u] | |
| return out | |
| def exact_walsh_checks(): | |
| count = 0 | |
| for n in range(1, 9): | |
| nv = 1 << n | |
| for mask in range(nv): | |
| w = [F((-1) ** ((x & mask).bit_count())) for x in range(nv)] | |
| actual = apply_h0(n, w) | |
| eigenvalue = 2 * (n - mask.bit_count()) | |
| assert actual == [eigenvalue * a for a in w] | |
| count += 1 | |
| chi = [F(parity(x)) for x in range(nv)] | |
| ones = [F(1)] * nv | |
| indicator = [F(parity(x) == 1) for x in range(nv)] | |
| # Unit-energy parity mask b=indicator/sqrt(N/2). Its rank-one update | |
| # bb^T is rational, so its invariant 2D action is checked exactly. | |
| def augmented(x): | |
| update = dot(indicator, x) / (F(nv, 2)) | |
| return [a + update * b for a, b in zip(apply_h0(n, x), indicator)] | |
| assert augmented(chi) == [(a + b) / 2 for a, b in zip(chi, ones)] | |
| assert augmented(ones) == [(a + b) / 2 + 2 * n * b | |
| for a, b in zip(chi, ones)] | |
| # Compression matrix [[1/2,1/2],[1/2,2n+1/2]] has trace2n+1, detn. | |
| assert F(1, 2) * (2 * n + F(1, 2)) - F(1, 4) == n | |
| assert dot(indicator, chi) ** 2 == F(nv, 2) * dot(indicator, indicator) | |
| count += 4 | |
| return count | |
| def exact_resource_checks(): | |
| rng = random.Random(1372026) | |
| general = rank_one = mixtures = blocks = support = 0 | |
| sharp_examples = 0 | |
| for n in range(2, 9): | |
| nv = 1 << n | |
| chi = [F(parity(x)) for x in range(nv)] | |
| for _ in range(20): | |
| b = [F(rng.randrange(0, 10), rng.randrange(1, 7)) for _ in range(nv)] | |
| assert dot(b, chi) ** 2 * 2 <= nv * dot(b, b) | |
| general += 1 | |
| factors = [[F(rng.randrange(0, 10), rng.randrange(1, 6)) | |
| for _ in range(2)] for _ in range(n)] | |
| v = tensor(factors) | |
| assert dot(v, chi) ** 2 <= dot(v, v) | |
| rank_one += 1 | |
| for rank in range(1, 6): | |
| for _ in range(8): | |
| terms = [tensor([[F(rng.randrange(0, 8), rng.randrange(1, 5)) | |
| for _ in range(2)] for _ in range(n)]) | |
| for _ in range(rank)] | |
| b = [sum((term[x] for term in terms), F(0)) for x in range(nv)] | |
| assert dot(b, chi) ** 2 <= rank * dot(b, b) | |
| assert sum((dot(v, v) for v in terms), F(0)) <= dot(b, b) | |
| mixtures += 1 | |
| # Any partition into k blocks, with a nonnegative factor per block, | |
| # has normalized parity overlap squared at most 2^-k. | |
| for k in range(1, n + 1): | |
| sizes = [1] * k | |
| for j in range(n - k): | |
| sizes[j % k] += 1 | |
| for _ in range(8): | |
| factors = [[F(rng.randrange(0, 10), rng.randrange(1, 7)) | |
| for _ in range(1 << size)] for size in sizes] | |
| b = tensor(factors) | |
| assert dot(b, chi) ** 2 * (1 << k) <= nv * dot(b, b) | |
| blocks += 1 | |
| # Exact sharpness of the overlap rank bound for R<=N/2: equal point | |
| # masses at R even vertices form a nonnegative CP-rank-R tensor. | |
| even = [x for x in range(nv) if parity(x) == 1] | |
| for rank in (1, min(3, len(even)), len(even)): | |
| b = [F(x in even[:rank]) for x in range(nv)] | |
| assert dot(b, chi) ** 2 == rank * dot(b, b) | |
| sharp_examples += 1 | |
| for size in (1, 2, nv // 2): | |
| indices = rng.sample(range(nv), size) | |
| b = [F(rng.randrange(1, 8) if x in indices else 0) for x in range(nv)] | |
| assert dot(b, chi) ** 2 <= size * dot(b, b) | |
| support += 1 | |
| return {"nonnegative_overlap": general, "coordinate_product_overlap": rank_one, | |
| "nonnegative_CP_mixture_overlap": mixtures, | |
| "block_product_overlap": blocks, "support_size_overlap": support, | |
| "rank_bound_sharp_overlap_examples": sharp_examples} | |
| def exact_rectangle_checks(): | |
| checks = 0 | |
| for n in range(1, 9): | |
| # 0 fixes the bit to0, 1 to1, and2 allows both; each is a nonempty | |
| # support of one nonnegative one-coordinate factor. | |
| for pattern in product((0, 1, 2), repeat=n): | |
| free = pattern.count(2) | |
| if free: | |
| # Flipping one free coordinate changes parity within support. | |
| a = [0 if p == 2 else p for p in pattern] | |
| b = list(a) | |
| b[pattern.index(2)] = 1 | |
| assert sum(a) % 2 != sum(b) % 2 | |
| else: | |
| assert 2 ** free == 1 | |
| checks += 1 | |
| return checks | |
| def matrix_rank(a): | |
| a = [list(map(F, row)) for row in a] | |
| if not a: | |
| return 0 | |
| rank = 0 | |
| for col in range(len(a[0])): | |
| pivot = next((j for j in range(rank, len(a)) if a[j][col]), None) | |
| if pivot is None: | |
| continue | |
| a[rank], a[pivot] = a[pivot], a[rank] | |
| value = a[rank][col] | |
| a[rank] = [v / value for v in a[rank]] | |
| for j in range(len(a)): | |
| if j != rank and a[j][col]: | |
| value = a[j][col] | |
| a[j] = [x - value * y for x, y in zip(a[j], a[rank])] | |
| rank += 1 | |
| if rank == len(a): | |
| break | |
| return rank | |
| def weighted_balanced(n, edges): | |
| values = [None] * n | |
| values[0] = F(1) | |
| changed = True | |
| balanced = True | |
| while changed: | |
| changed = False | |
| for u, v, alpha in edges: | |
| if values[u] is not None: | |
| proposed = -values[u] / alpha | |
| if values[v] is None: | |
| values[v] = proposed | |
| changed = True | |
| elif values[v] != proposed: | |
| balanced = False | |
| elif values[v] is not None: | |
| values[u] = -alpha * values[v] | |
| changed = True | |
| assert all(x is not None for x in values) | |
| return balanced | |
| def exact_gain_graph_checks(): | |
| rng = random.Random(2262026) | |
| count = 0 | |
| for n in range(2, 11): | |
| for rep in range(18): | |
| edges = [(i, i + 1, F(rng.randrange(1, 5), rng.randrange(1, 5))) | |
| for i in range(n - 1)] | |
| for _ in range(rep % 4): | |
| u, v = rng.sample(range(n), 2) | |
| edges.append((u, v, F(rng.randrange(1, 5), rng.randrange(1, 5)))) | |
| rows = [] | |
| for u, v, alpha in edges: | |
| row = [F(0)] * n | |
| row[u], row[v] = F(1), alpha | |
| rows.append(row) | |
| assert matrix_rank(rows) == n - int(weighted_balanced(n, edges)) | |
| count += 1 | |
| return count | |
| def numerical_spectral_checks(): | |
| try: | |
| import numpy as np | |
| except ImportError: | |
| return {"status": "SKIPPED", "reason": "NumPy is optional for spectral illustrations"} | |
| rng = np.random.default_rng(12202026) | |
| cases = mixtures = pair_cases = 0 | |
| curve = [] | |
| worst_excess = 0.0 | |
| for n in range(1, 8): | |
| nv = 1 << n | |
| q = n * np.eye(nv) | |
| for u, v in cube_edges(n): | |
| q[u, v] = q[v, u] = 1 | |
| signs = np.array([parity(x) for x in range(nv)], dtype=float) | |
| even = (signs == 1).astype(float) | |
| odd = (signs == -1).astype(float) | |
| b_opt = even / np.linalg.norm(even) | |
| optimum = (2 * n) / (2 * n + 1 + sqrt(4 * n * n + 1)) | |
| got = float(np.linalg.eigvalsh(q + np.outer(b_opt, b_opt))[0]) | |
| assert abs(got - optimum) < 2e-11 | |
| for _ in range(18): | |
| b = rng.uniform(0, 1, size=nv) | |
| b /= np.linalg.norm(b) | |
| val = float(np.linalg.eigvalsh(q + np.outer(b, b))[0]) | |
| assert val <= optimum + 2e-11 | |
| worst_excess = max(worst_excess, val - optimum) | |
| cases += 1 | |
| # Total energy1, two positive rows: each parity indicator/sqrt(N). | |
| h = q + (np.outer(even, even) + np.outer(odd, odd)) / nv | |
| assert abs(float(np.linalg.eigvalsh(h)[0]) - 0.5) < 2e-11 | |
| pair_cases += 1 | |
| if n >= 2: | |
| for rank in (1, 2, 3): | |
| vectors = [] | |
| for _ in range(2): | |
| terms = [] | |
| for _ in range(rank): | |
| v = np.array([1.0]) | |
| for _ in range(n): | |
| v = np.kron(v, rng.uniform(0, 1, size=2)) | |
| terms.append(v) | |
| b = sum(terms) | |
| b /= np.linalg.norm(b) | |
| vectors.append(b) | |
| h = q + sum(np.outer(b, b) for b in vectors) | |
| val = float(np.linalg.eigvalsh(h)[0]) | |
| assert val <= 2 * rank / nv + 2e-11 | |
| mixtures += 1 | |
| curve.append({"dimension": n, "vertices": nv, | |
| "optimal_one_positive_row": optimum, | |
| "two_positive_rows_total_energy_one": 0.5, | |
| "single_product_row_upper_bound": 1 / nv, | |
| "eigensolver_parity_value": got}) | |
| return {"status": "PASS", "arithmetic": "NumPy float64 symmetric eigensolver", | |
| "random_single_row_cases": cases, "CP_resource_spectral_cases": mixtures, | |
| "two_row_optimal_frame_cases": pair_cases, | |
| "maximum_observed_excess_over_optimum": worst_excess, "curve": curve} | |
| def main(): | |
| return {"status": "PASS", "exact_arithmetic": "integer/Fraction", | |
| "exact_walsh_and_optimal_invariant_space_checks": exact_walsh_checks(), | |
| "exact_resource_checks": exact_resource_checks(), | |
| "exact_parity_rectangle_support_checks": exact_rectangle_checks(), | |
| "exact_weighted_gain_graph_rank_checks": exact_gain_graph_checks(), | |
| "spectral_illustrations": numerical_spectral_checks(), | |
| "scope": ["Proofs, not random search, establish the universal optimum.", | |
| "The unscaled baseline is all binary coordinate-fiber edge sums.", | |
| "Total probe energy is squared Euclidean row norm, not runtime.", | |
| "One dense mask may require exponentially many state accesses.", | |
| "CP rank means nonnegative coordinatewise tensor rank."]} | |
| if __name__ == '__main__': | |
| result = main() | |
| print(json.dumps(result, indent=2)) | |