Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
tensor-tomography
inverse-problems
positive-sensing
reproducible-research
Synthetic
| #!/usr/bin/env python3 | |
| """Exact finite tests for temperature-complete tomography and its trades. | |
| Python standard library only. Powers of positive integer z stand for the | |
| unnormalized measurements at inverse temperatures k*beta0. No numerical | |
| Laplace inversion or root finder is used. Proofs are in trades_notes.md. | |
| """ | |
| from collections import Counter, defaultdict | |
| from fractions import Fraction | |
| from itertools import combinations, product | |
| import json | |
| def grid(shape): | |
| return list(product(*(range(q) for q in shape))) | |
| def lines(shape): | |
| points = grid(shape) | |
| out = [] | |
| for axis in range(len(shape)): | |
| groups = defaultdict(list) | |
| for p in points: | |
| groups[p[:axis] + p[axis + 1:]].append(p) | |
| out.extend(tuple(group) for _, group in sorted(groups.items())) | |
| return out | |
| def signature(values, points, coordinate_lines): | |
| at = dict(zip(points, values)) | |
| return tuple(tuple(sorted(at[p] for p in line)) for line in coordinate_lines) | |
| def is_rectangular_checkerboard(h, shape): | |
| support = [p for p, value in h.items() if value] | |
| levels = [sorted({p[i] for p in support}) for i in range(len(shape))] | |
| if any(len(level) != 2 for level in levels): | |
| return False | |
| if set(support) != set(product(*levels)): | |
| return False | |
| reference = tuple(level[0] for level in levels) | |
| amplitude = h[reference] | |
| return all(h[p] == amplitude * (-1) ** sum( | |
| p[i] == levels[i][1] for i in range(len(shape))) for p in support) | |
| def complete_line_zero(interior_values, shape): | |
| """Expand free interior coefficients in tensor (e_a-e_last) bases.""" | |
| n = len(shape) | |
| interior_points = list(product(*(range(q - 1) for q in shape))) | |
| coefficients = dict(zip(interior_points, interior_values)) | |
| h = {} | |
| for p in grid(shape): | |
| missing = [i for i in range(n) if p[i] == shape[i] - 1] | |
| total = 0 | |
| choices = [range(shape[i] - 1) if i in missing else (p[i],) | |
| for i in range(n)] | |
| for a in product(*choices): | |
| total += coefficients[a] | |
| h[p] = (-1) ** len(missing) * total | |
| return h | |
| def check_line_zero_enumeration(): | |
| shape = (3, 3, 3) | |
| coordinate_lines = lines(shape) | |
| total = nonzero = signed = minimum_support = 0 | |
| minimum_positive = 99 | |
| support_histogram = Counter() | |
| for interior in product((-1, 0, 1), repeat=8): | |
| h = complete_line_zero(interior, shape) | |
| assert all(sum(h[p] for p in line) == 0 for line in coordinate_lines) | |
| total += 1 | |
| if not any(h.values()): | |
| continue | |
| nonzero += 1 | |
| support = sum(value != 0 for value in h.values()) | |
| positives = sum(value > 0 for value in h.values()) | |
| negatives = sum(value < 0 for value in h.values()) | |
| assert support >= 8 and positives >= 4 and negatives >= 4 | |
| minimum_positive = min(minimum_positive, positives) | |
| support_histogram[support] += 1 | |
| if max(map(abs, h.values())) <= 1: | |
| signed += 1 | |
| if support == 8: | |
| assert is_rectangular_checkerboard(h, shape) | |
| minimum_support += 1 | |
| return {"shape": list(shape), "interior_arrays": total, | |
| "nonzero_line_zero_tensors": nonzero, | |
| "signed_nonzero_tensors": signed, | |
| "minimum_support_tensors": minimum_support, | |
| "minimum_positive_support": minimum_positive, | |
| "support_histogram": dict(sorted(support_histogram.items()))} | |
| def check_colored_fibers(shape, alphabet): | |
| points = grid(shape) | |
| coordinate_lines = lines(shape) | |
| fibers = defaultdict(list) | |
| total = 0 | |
| for values in product(alphabet, repeat=len(points)): | |
| fibers[signature(values, points, coordinate_lines)].append(values) | |
| total += 1 | |
| pair_checks = minimal_trade_pairs = bounded_multiplicity_fields = 0 | |
| threshold = 2 ** (len(shape) - 1) | |
| for fiber in fibers.values(): | |
| for values in fiber: | |
| if max(Counter(values).values()) < threshold: | |
| assert len(fiber) == 1 | |
| bounded_multiplicity_fields += 1 | |
| for a, b in combinations(fiber, 2): | |
| changed = [p for p, va, vb in zip(points, a, b) if va != vb] | |
| assert len(changed) >= 2 ** len(shape) | |
| moved_colors = set() | |
| for color in set(a) | set(b): | |
| h = {p: int(va == color) - int(vb == color) | |
| for p, va, vb in zip(points, a, b)} | |
| if any(h.values()): | |
| moved_colors.add(color) | |
| assert sum(value > 0 for value in h.values()) >= threshold | |
| assert Counter(a)[color] >= threshold | |
| assert all(sum(h[p] for p in line) == 0 | |
| for line in coordinate_lines) | |
| if len(changed) == 2 ** len(shape): | |
| assert len(moved_colors) == 2 | |
| color = next(iter(moved_colors)) | |
| h = {p: int(va == color) - int(vb == color) | |
| for p, va, vb in zip(points, a, b)} | |
| assert is_rectangular_checkerboard(h, shape) | |
| minimal_trade_pairs += 1 | |
| pair_checks += 1 | |
| return {"shape": list(shape), "alphabet": list(alphabet), | |
| "fields": total, "fibers": len(fibers), | |
| "ambiguous_fibers": sum(len(fiber) > 1 for fiber in fibers.values()), | |
| "equal_data_pair_checks": pair_checks, | |
| "minimal_trade_pair_checks": minimal_trade_pairs, | |
| "multiplicity_threshold": threshold, | |
| "bounded_multiplicity_fields_certified_unique": bounded_multiplicity_fields} | |
| def elementary_from_powers(powers): | |
| e = [Fraction(1)] | |
| for m in range(1, len(powers) + 1): | |
| e.append(sum(((-1) ** (k - 1) * e[m - k] * powers[k - 1] | |
| for k in range(1, m + 1)), Fraction(0)) / m) | |
| return e | |
| def polynomial_of_roots(values): | |
| coefficients = [Fraction(1)] | |
| for z in values: | |
| following = [Fraction(0)] * (len(coefficients) + 1) | |
| for j, coefficient in enumerate(coefficients): | |
| following[j] += coefficient | |
| following[j + 1] -= z * coefficient | |
| coefficients = following | |
| return coefficients | |
| def check_newton_moments(): | |
| cases = multiset_fibers = 0 | |
| for length in range(2, 6): | |
| seen = {} | |
| for values in product(range(1, 5), repeat=length): | |
| powers = tuple(sum(z ** k for z in values) for k in range(1, length + 1)) | |
| elementary = elementary_from_powers(powers) | |
| polynomial = [(-1) ** k * e for k, e in enumerate(elementary)] | |
| assert polynomial == polynomial_of_roots(values) | |
| multiset = tuple(sorted(values)) | |
| assert powers not in seen or seen[powers] == multiset | |
| seen[powers] = multiset | |
| cases += 1 | |
| multiset_fibers += len(seen) | |
| return {"line_lengths": [2, 3, 4, 5], | |
| "ordered_line_cases": cases, | |
| "distinct_multisets": multiset_fibers} | |
| def check_sharp_embedded_trades(): | |
| cases = moment_checks = 0 | |
| for n in range(2, 6): | |
| shape = (3,) * n | |
| points = grid(shape) | |
| coordinate_lines = lines(shape) | |
| a, b = {}, {} | |
| fresh = 100 | |
| for p in points: | |
| if all(x < 2 for x in p): | |
| a[p] = 2 if sum(p) % 2 == 0 else 5 | |
| b[p] = 5 if sum(p) % 2 == 0 else 2 | |
| else: | |
| a[p] = b[p] = fresh | |
| fresh += 1 | |
| assert sum(a[p] != b[p] for p in points) == 2 ** n | |
| assert Counter(a.values())[2] == Counter(a.values())[5] == 2 ** (n - 1) | |
| assert signature([a[p] for p in points], points, coordinate_lines) == signature( | |
| [b[p] for p in points], points, coordinate_lines) | |
| for line in coordinate_lines: | |
| for power in range(1, 7): | |
| assert sum(a[p] ** power for p in line) == sum(b[p] ** power for p in line) | |
| moment_checks += 1 | |
| cases += 1 | |
| # Three distinct cyclic tensors have identical line multisets and are | |
| # therefore invisible at all temperatures. They are not a global two-color | |
| # parity interchange on the ternary domain. | |
| cyclic_cases = 0 | |
| for n in (2, 3, 4): | |
| shape = (3,) * n | |
| points = grid(shape) | |
| coordinate_lines = lines(shape) | |
| tensors = [[(2, 5, 11)[(sum(p) + phase) % 3] for p in points] | |
| for phase in range(3)] | |
| signatures = [signature(v, points, coordinate_lines) for v in tensors] | |
| assert signatures[0] == signatures[1] == signatures[2] | |
| assert len(set(map(tuple, tensors))) == 3 | |
| cyclic_cases += 1 | |
| return {"sharp_rectangular_examples": cases, | |
| "exact_power_projection_checks": moment_checks, | |
| "cyclic_ternary_examples": cyclic_cases} | |
| def run(): | |
| return {"status": "PASS", "arithmetic": "exact integers and Fractions", | |
| "line_zero_kernel": check_line_zero_enumeration(), | |
| "colored_fibers": [check_colored_fibers((2, 2, 2), range(3)), | |
| check_colored_fibers((3, 3), range(3))], | |
| "finite_temperature_moments": check_newton_moments(), | |
| "sharp_examples": check_sharp_embedded_trades(), | |
| "primary_prior_art": [ | |
| "https://arxiv.org/abs/0704.1730", | |
| "https://arxiv.org/abs/1104.1295", | |
| "https://eccc.weizmann.ac.il/report/2008/105/download/"], | |
| "scope": "Finite checks support the manuscript proofs; no novelty claim follows."} | |
| if __name__ == "__main__": | |
| print(json.dumps(run(), indent=2, sort_keys=True)) | |