| """Constant-ray rectangular packet maps and exact augmentation decoding. |
| |
| Python 3.10+, standard library only. Geometry and payload fields can differ. |
| The finite packet iteration requires matching characteristic; the direct |
| rectangular Gaussian decoder does not. Packet matrices need not commute. |
| |
| The small oblique quotient has (q-1)*L rows and (q-1)*ell columns. Its ordinary |
| left inverse is applied to radial groups. The error operator is nilpotent in |
| at most 1+r*(d-1)*(p-1) sweeps; for affine-basis slabs the bound is 1+d*(p-1). |
| """ |
|
|
| from affine_core import Field, inverse, matvec, rank |
|
|
|
|
| def left_inverse(matrix, field): |
| """Return D with D*matrix=I; reject deficient column rank. |
| |
| Select independent rows by elimination on the transpose, then invert only |
| that square minor. For an a-by-b matrix, a>=b, this costs O(a*b*b). |
| """ |
| a = len(matrix) |
| b = len(matrix[0]) if a else 0 |
| if any(len(row) != b for row in matrix): |
| raise ValueError("ragged matrix") |
| if not b: |
| return [] |
| if a < b: |
| raise ValueError("matrix has fewer rows than columns") |
| work = [[matrix[i][j] for i in range(a)] for j in range(b)] |
| selected = [] |
| r = 0 |
| for col in range(a): |
| pivot = next((i for i in range(r, b) if work[i][col]), None) |
| if pivot is None: |
| continue |
| work[r], work[pivot] = work[pivot], work[r] |
| scale = field.inv(work[r][col]) |
| work[r] = [field.mul(scale, x) for x in work[r]] |
| for i in range(r + 1, b): |
| factor = work[i][col] |
| if factor: |
| work[i] = [ |
| field.sub(x, field.mul(factor, y)) |
| for x, y in zip(work[i], work[r]) |
| ] |
| selected.append(col) |
| r += 1 |
| if r == b: |
| break |
| if r != b: |
| raise ValueError("matrix does not have full column rank") |
| minor_inverse = inverse([matrix[i] for i in selected], field) |
| result = [[0] * a for _ in range(b)] |
| for row in range(b): |
| for j, col in enumerate(selected): |
| result[row][col] = minor_inverse[row][j] |
| return result |
|
|
|
|
| def solve_full_column(matrix, rhs, field): |
| """Solve a full-column-rank rectangular system and check consistency.""" |
| if len(matrix) != len(rhs): |
| raise ValueError("right-hand side length mismatch") |
| result = matvec(left_inverse(matrix, field), rhs, field) |
| if matvec(matrix, result, field) != list(rhs): |
| raise ValueError("inconsistent rectangular system") |
| return result |
|
|
|
|
| def polynomial_matrix(weight, source_length, parity_length): |
| """L-by-ell convolution matrix of a scalar polynomial modulo T**L.""" |
| if source_length < 1 or parity_length < source_length: |
| raise ValueError("require 1 <= source_length <= parity_length") |
| if len(weight) > parity_length: |
| raise ValueError("polynomial exceeds parity precision") |
| padded = list(weight) + [0] * (parity_length - len(weight)) |
| return [ |
| [padded[u - v] if u >= v else 0 for v in range(source_length)] |
| for u in range(parity_length) |
| ] |
|
|
|
|
| def _prime_span_dimension(vectors, geometry_field): |
| """F_p-rank of vectors in the polynomial coordinate representation of F_q.""" |
| p, r = geometry_field.p, geometry_field.n |
| expanded = [ |
| [(x // (p ** k)) % p for x in vector for k in range(r)] |
| for vector in vectors |
| ] |
| return rank(expanded, Field(p)) |
|
|
|
|
| class MatrixCodec: |
| """Systematic encoder with a constant L-by-ell matrix on each listed ray. |
| |
| Geometry is an affine_core.Geometry, whose default rays are 0,e_1,...,e_d. |
| A geometry with a different spanning rays list is also supported. Zero ray |
| matrices are permitted. Packets are lists/tuples of field element labels. |
| """ |
|
|
| def __init__(self, geometry, coefficient, matrices): |
| if len(matrices) != len(geometry.rays) or not matrices: |
| raise ValueError("one packet matrix per listed ray is required") |
| L = len(matrices[0]) |
| ell = len(matrices[0][0]) if L else 0 |
| if not 1 <= ell <= L: |
| raise ValueError("packet dimensions must satisfy 1 <= ell <= L") |
| for matrix in matrices: |
| if len(matrix) != L or any(len(row) != ell for row in matrix): |
| raise ValueError("all ray matrices must have the same dimensions") |
| if any(x not in range(coefficient.q) for row in matrix for x in row): |
| raise ValueError("invalid coefficient-field matrix entry") |
| self.g, self.f = geometry, coefficient |
| self.ell, self.b, self.L = ell, ell, L |
| self.A = tuple(tuple(tuple(row) for row in matrix) for matrix in matrices) |
| self._sites = set(geometry.sites) |
| self._data = set(geometry.data) |
| self._prepared = {} |
|
|
| @classmethod |
| def from_polynomials( |
| cls, geometry, coefficient, source_length, parity_length, weights |
| ): |
| """Represent any polynomial assignment, including singular leading terms.""" |
| matrices = [ |
| polynomial_matrix(weight, source_length, parity_length) |
| for weight in weights |
| ] |
| result = cls(geometry, coefficient, matrices) |
| result.weights = tuple( |
| tuple(weight) + (0,) * (parity_length - len(weight)) |
| for weight in weights |
| ) |
| return result |
|
|
| def _valid_packet(self, packet, size): |
| return len(packet) == size and all(x in range(self.f.q) for x in packet) |
|
|
| def encode(self, source): |
| if set(source) != self._data: |
| raise ValueError("source addresses must be precisely the data set") |
| if any(not self._valid_packet(x, self.ell) for x in source.values()): |
| raise ValueError("invalid source packet") |
| out = {site: list(packet) for site, packet in source.items()} |
| out.update({site: [0] * self.L for site in self.g.parity}) |
| for site, packet in source.items(): |
| for j, matrix in enumerate(self.A): |
| parity_site = self.g.project(site, j) |
| contribution = matvec(matrix, packet, self.f) |
| out[parity_site] = [ |
| self.f.add(x, y) |
| for x, y in zip(out[parity_site], contribution) |
| ] |
| return out |
|
|
| def block_matrix(self, plan): |
| """Direct physical-coordinate matrix, independent of the quotient decoder.""" |
| h = len(plan["missing"]) |
| result = [[0] * (h * self.ell) for _ in range(h * self.L)] |
| for j in plan["active"]: |
| matrix = self.A[j] |
| for row, col in enumerate(plan["maps"][j]): |
| for u in range(self.L): |
| for v in range(self.ell): |
| a, b = row * self.L + u, col * self.ell + v |
| result[a][b] = self.f.add(result[a][b], matrix[u][v]) |
| return result |
|
|
| def _radial_matrix(self, active, gamma): |
| gf = self.g.f |
| reference = active[0] |
| cs = list(range(1, gf.q)) |
| positions = {c: i for i, c in enumerate(cs)} |
| ratios = {j: gf.div(gamma[reference], gamma[j]) for j in active} |
| result = [[0] * (len(cs) * self.ell) for _ in range(len(cs) * self.L)] |
| for i, c in enumerate(cs): |
| for j in active: |
| k = positions[gf.mul(ratios[j], c)] |
| for u in range(self.L): |
| for v in range(self.ell): |
| row, col = i * self.L + u, k * self.ell + v |
| result[row][col] = self.f.add(result[row][col], self.A[j][u][v]) |
| return result |
|
|
| def _slab_matrix(self, active): |
| return [ |
| [self.f.sum(self.A[j][u][v] for j in active) for v in range(self.ell)] |
| for u in range(self.L) |
| ] |
|
|
| def certificate(self, method="augmentation"): |
| """Return an exact universal certificate or its first failing orientation. |
| |
| Augmentation checks one small quotient per normal class in matched |
| characteristic. Direct certification checks every physical hyperplane |
| and works in any coding characteristic, at a greater computational cost. |
| """ |
| if method not in ("augmentation", "direct"): |
| raise ValueError("unknown certification method") |
| if method == "augmentation" and self.f.p != self.g.f.p: |
| raise ValueError("augmentation certification requires matching characteristic") |
| checked = 0 |
| if method == "direct": |
| for normal, offset in self.g.hyperplanes(): |
| plan = self.g.plan(normal, offset) |
| columns = len(plan["missing"]) * self.ell |
| if rank(self.block_matrix(plan), self.f) != columns: |
| return { |
| "universal": False, "method": method, "checked": checked + 1, |
| "normal": normal, "offset": offset, |
| } |
| checked += 1 |
| else: |
| for normal in self.g.normal_classes(): |
| a, beta = normal[:-1], normal[-1] |
| gamma = [ |
| self.g.f.add(beta, self.g.dot(a, w)) for w in self.g.rays |
| ] |
| active = [j for j, value in enumerate(gamma) if value] |
| if not active: |
| return { |
| "universal": False, "method": method, "checked": checked + 1, |
| "normal": normal, "reason": "all rays inactive", |
| } |
| matrix = ( |
| self._radial_matrix(active, gamma) if any(a) |
| else self._slab_matrix(active) |
| ) |
| if rank(matrix, self.f) != len(matrix[0]): |
| return { |
| "universal": False, "method": method, "checked": checked + 1, |
| "normal": normal, "reason": "deficient augmentation rank", |
| } |
| checked += 1 |
| return {"universal": True, "method": method, "checked": checked} |
|
|
| def certified(self, method="augmentation"): |
| return self.certificate(method)["universal"] |
|
|
| def residual(self, observed, plan): |
| missing = set(plan["missing"]) |
| needed = (self._data - missing) | set(plan["live"]) |
| if not needed.issubset(observed): |
| raise ValueError("erasures extend outside the supplied containing hyperplane") |
| for site, packet in observed.items(): |
| if site not in self._sites: |
| raise ValueError("invalid observed address") |
| size = self.L if site[-1] == 0 else self.ell |
| if not self._valid_packet(packet, size): |
| raise ValueError("invalid observed packet") |
| rows = {site: i for i, site in enumerate(plan["live"])} |
| result = [list(observed[site]) for site in plan["live"]] |
| for site in self.g.data: |
| if site in missing: |
| continue |
| for j, matrix in enumerate(self.A): |
| row = rows.get(self.g.project(site, j)) |
| if row is not None: |
| contribution = matvec(matrix, observed[site], self.f) |
| result[row] = [ |
| self.f.sub(x, y) for x, y in zip(result[row], contribution) |
| ] |
| return result |
|
|
| def prepare(self, normal, offset): |
| """Prepare an ordinary small quotient left inverse and radial grouping.""" |
| if self.f.p != self.g.f.p: |
| raise ValueError("finite augmentation decoding requires matching characteristic") |
| key = (tuple(normal), offset) |
| if key in self._prepared: |
| return self._prepared[key] |
| plan = self.g.plan(normal, offset) |
| h = len(plan["missing"]) |
| if not h: |
| prepared = { |
| "plan": plan, "h": 0, "groups": [], "B0": [], "D0": [], |
| "bound": 0, "row_for_source": [], "relative_maps": {}, |
| } |
| self._prepared[key] = prepared |
| return prepared |
| active = plan["active"] |
| reference = active[0] |
| |
| |
| row_for_source = [None] * h |
| for row, col in enumerate(plan["maps"][reference]): |
| row_for_source[col] = row |
| relative_maps = { |
| j: [plan["maps"][j][row_for_source[i]] for i in range(h)] |
| for j in active |
| } |
| a = plan["normal"][:-1] |
| if any(a): |
| pivot = next(i for i, x in enumerate(a) if x) |
| cs = list(range(1, self.g.q)) |
| radial_position = {c: i for i, c in enumerate(cs)} |
| grouping = {} |
| |
| |
| |
| for i, site in enumerate(plan["missing"]): |
| tangent = tuple(x for k, x in enumerate(site[:-1]) if k != pivot) |
| grouping.setdefault(tangent, [None] * len(cs))[ |
| radial_position[site[-1]] |
| ] = i |
| groups = list(grouping.values()) |
| if any(None in group for group in groups): |
| raise AssertionError("incomplete radial group") |
| B0 = self._radial_matrix(active, plan["gamma"]) |
| bound = 1 + self.g.f.n * (self.g.d - 1) * (self.f.p - 1) |
| else: |
| groups = [[i] for i in range(h)] |
| B0 = self._slab_matrix(active) |
| base = self.g.rays[reference] |
| differences = [ |
| tuple(self.g.f.sub(x, y) for x, y in zip(self.g.rays[j], base)) |
| for j in active |
| ] |
| e = _prime_span_dimension(differences, self.g.f) |
| bound = 1 + e * (self.f.p - 1) |
| D0 = left_inverse(B0, self.f) |
| prepared = { |
| "plan": plan, "h": h, "groups": groups, "B0": B0, "D0": D0, |
| "bound": bound, "row_for_source": row_for_source, |
| "relative_maps": relative_maps, |
| } |
| self._prepared[key] = prepared |
| return prepared |
|
|
| def apply_aligned(self, prepared, source_packets): |
| """Apply M after reference row alignment, also useful for operator audits.""" |
| h = prepared["h"] |
| if len(source_packets) != h: |
| raise ValueError("source array length mismatch") |
| if not h: |
| return [] |
| result = [[0] * self.L for _ in range(h)] |
| for j in prepared["plan"]["active"]: |
| matrix = self.A[j] |
| for row, col in enumerate(prepared["relative_maps"][j]): |
| contribution = matvec(matrix, source_packets[col], self.f) |
| result[row] = [ |
| self.f.add(x, y) for x, y in zip(result[row], contribution) |
| ] |
| return result |
|
|
| def apply_left_inverse(self, prepared, residual_packets): |
| """Apply the small ordinary D0 separately on each tangent fiber.""" |
| result = [[0] * self.ell for _ in range(prepared["h"])] |
| for group in prepared["groups"]: |
| flat = [x for i in group for x in residual_packets[i]] |
| values = matvec(prepared["D0"], flat, self.f) |
| for k, i in enumerate(group): |
| result[i] = values[k * self.ell:(k + 1) * self.ell] |
| return result |
|
|
| def error_step(self, prepared, source_packets): |
| """Apply I-D0*M; its advertised power vanishes for a certified cut.""" |
| correction = self.apply_left_inverse( |
| prepared, self.apply_aligned(prepared, source_packets) |
| ) |
| return [ |
| [self.f.sub(x, y) for x, y in zip(packet, delta)] |
| for packet, delta in zip(source_packets, correction) |
| ] |
|
|
| def solve_prepared(self, prepared, residual_packets): |
| """Solve from surviving-parity order, returning missing-source order.""" |
| h = prepared["h"] |
| if len(residual_packets) != h: |
| raise ValueError("residual array length mismatch") |
| if not h: |
| return [] |
| rhs = [residual_packets[i] for i in prepared["row_for_source"]] |
| values = [[0] * self.ell for _ in range(h)] |
| for _ in range(prepared["bound"]): |
| applied = self.apply_aligned(prepared, values) |
| residual = [ |
| [self.f.sub(x, y) for x, y in zip(packet, image)] |
| for packet, image in zip(rhs, applied) |
| ] |
| delta = self.apply_left_inverse(prepared, residual) |
| values = [ |
| [self.f.add(x, y) for x, y in zip(packet, step)] |
| for packet, step in zip(values, delta) |
| ] |
| return values |
|
|
| def decode(self, observed, normal, offset, method="nilpotent", verify=True): |
| """Recover the complete source from a full or partial hyperplane erasure.""" |
| if method not in ("nilpotent", "gaussian"): |
| raise ValueError("unknown decoder") |
| plan = self.g.plan(normal, offset) |
| rhs = self.residual(observed, plan) |
| h = len(plan["missing"]) |
| if not h: |
| values, bound, quotient_shape = [], 0, [0, 0] |
| elif method == "gaussian": |
| flat = solve_full_column( |
| self.block_matrix(plan), [x for packet in rhs for x in packet], self.f |
| ) |
| values = [flat[i * self.ell:(i + 1) * self.ell] for i in range(h)] |
| bound, quotient_shape = None, None |
| else: |
| prepared = self.prepare(normal, offset) |
| values = self.solve_prepared(prepared, rhs) |
| bound = prepared["bound"] |
| quotient_shape = [len(prepared["B0"]), len(prepared["B0"][0])] |
| missing = set(plan["missing"]) |
| source = { |
| site: list(observed[site]) for site in self.g.data if site not in missing |
| } |
| source.update(zip(plan["missing"], values)) |
| if verify: |
| rebuilt = self.encode(source) |
| if any(rebuilt[site] != list(packet) for site, packet in observed.items()): |
| raise ValueError("surviving equations are inconsistent") |
| return source, { |
| "method": method, |
| "unknown_packets": h, |
| "source_symbols_per_packet": self.ell, |
| "parity_symbols_per_packet": self.L, |
| "iterations": bound, |
| "small_quotient_shape": quotient_shape, |
| "dense_global_solve": method == "gaussian" and h > 0, |
| } |
|
|
|
|
| def noncommuting_binary_four(): |
| """Explicit four-bit triple whose nonzero GF(4)-linear sums are nonsingular.""" |
| return [ |
| [[int(i == j) for j in range(4)] for i in range(4)], |
| [[0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 0], [0, 0, 1, 0]], |
| [[0, 1, 1, 1], [1, 1, 1, 0], [1, 1, 0, 0], [1, 0, 0, 0]], |
| ] |
|
|
|
|
