Datasets:
Formats:
csv
Languages:
English
Size:
< 1K
Tags:
recursive-self-improvement
meta-learning
learned-optimizers
homological-algebra
formal-methods
synthetic-data
| """Exact reciprocal repair, over GF(2). Python 3.10+, standard library only. | |
| Square matrices use one Python integer per row. Reported work is a specified | |
| word-RAM model, NOT FLOPs or a claimed hardware-neutral speedup. n <= 64. | |
| Every matrix traversal, word xor, set-bit scan, comparison, RNG draw and | |
| search bookkeeping has a deterministic charge; elapsed time is also reported. | |
| """ | |
| from __future__ import annotations | |
| from collections import Counter | |
| from dataclasses import dataclass, field | |
| import random | |
| Mat = tuple[int, ...] | |
| class BudgetExhausted(RuntimeError): | |
| pass | |
| class Meter: | |
| limit: int | None = None | |
| used: int = 0 | |
| counts: Counter = field(default_factory=Counter) | |
| def use(self, amount: int, kind: str = "misc") -> None: | |
| if self.limit is not None and self.used + amount > self.limit: | |
| remaining = self.limit - self.used | |
| self.counts[kind] += remaining | |
| self.used = self.limit | |
| raise BudgetExhausted | |
| self.used += amount | |
| self.counts[kind] += amount | |
| class Problem: | |
| d: Mat | |
| Q: Mat | |
| P: Mat | |
| h0: Mat | |
| grades: tuple[int, ...] | |
| def n(self) -> int: | |
| return len(self.d) | |
| def zero(n: int) -> Mat: | |
| return (0,) * n | |
| def eye(n: int) -> Mat: | |
| return tuple(1 << i for i in range(n)) | |
| def add(A: Mat, B: Mat, m: Meter) -> Mat: | |
| m.use(2 * len(A), "xor") | |
| return tuple(a ^ b for a, b in zip(A, B)) | |
| def mul(A: Mat, B: Mat, m: Meter) -> Mat: | |
| out = [] | |
| for row in A: | |
| m.use(2, "multiply") | |
| value = 0 | |
| while row: | |
| m.use(6, "multiply") | |
| low = row & -row | |
| value ^= B[low.bit_length() - 1] | |
| row ^= low | |
| out.append(value) | |
| return tuple(out) | |
| def nnz(A: Mat, m: Meter) -> int: | |
| m.use(2 * len(A), "score") | |
| return sum(row.bit_count() for row in A) | |
| def equal(A: Mat, B: Mat, m: Meter) -> bool: | |
| m.use(len(A), "compare") | |
| return A == B | |
| def differential(p: Problem, f: Mat, m: Meter) -> Mat: | |
| # Signs coincide in characteristic two, for every degree. | |
| return add(mul(p.d, f, m), mul(f, p.d, m), m) | |
| def K(p: Problem, h: Mat, f: Mat, m: Meter, cross: bool = True) -> Mat: | |
| hf = mul(h, f, m) | |
| if not cross: | |
| return hf | |
| return add(hf, mul(mul(p.Q, f, m), h, m), m) | |
| def valid(p: Problem, h: Mat, m: Meter) -> bool: | |
| z = zero(p.n) | |
| # Check all identities; do not short-circuit invalid candidates. | |
| checks = [equal(differential(p, h, m), p.P, m), | |
| equal(mul(h, h, m), z, m), | |
| equal(mul(p.Q, h, m), z, m), | |
| equal(mul(h, p.Q, m), z, m)] | |
| m.use(p.n * p.n, "degree_check") | |
| graded = all(not (row >> j & 1) or p.grades[i] == p.grades[j] - 1 | |
| for i, row in enumerate(h) for j in range(p.n)) | |
| return all(checks) and graded | |
| def normalize(p: Problem, g: Mat, m: Meter) -> Mat: | |
| return mul(mul(g, p.d, m), g, m) | |
| def repaired_candidate(p: Problem, current: Mat, generator: Mat, | |
| a: Mat, m: Meter, protect: bool = False) -> Mat: | |
| # z = P (a - K_generator(partial a)) P; minus = plus over GF(2). | |
| z = add(a, K(p, generator, differential(p, a, m), m), m) | |
| if protect: | |
| z = mul(mul(p.P, z, m), p.P, m) | |
| return normalize(p, add(current, z, m), m) | |
| def boundary_candidate(p: Problem, current: Mat, B: Mat, m: Meter) -> Mat: | |
| # Strong simple reduction: any fixed-Q closed variation is partial B. | |
| z = differential(p, B, m) | |
| # gdg automatically removes Q mixing; explicit P sandwiches are redundant. | |
| return normalize(p, add(current, z, m), m) | |
| def positions(p: Problem, degree: int, m: Meter) -> tuple[tuple[int, int], ...]: | |
| m.use(p.n * p.n, "setup") | |
| return tuple((i, j) for i in range(p.n) for j in range(p.n) | |
| if p.grades[i] == p.grades[j] + degree) | |
| def proposal(p: Problem, available: tuple[tuple[int, int], ...], | |
| rng: random.Random, m: Meter, width: int = 1) -> Mat: | |
| m.use(p.n + 7 * width, "proposal") | |
| rows = [0] * p.n | |
| for _ in range(width): | |
| i, j = available[rng.randrange(len(available))] | |
| rows[i] ^= 1 << j | |
| return tuple(rows) | |
| def kernel_work(p: Problem, h: Mat, tasks: list[Mat], | |
| charge: Meter | None = None) -> int: | |
| """Execute, rather than estimate, the kernel on fresh repair problems.""" | |
| local = Meter() | |
| for task in tasks: | |
| K(p, h, task, local) | |
| if charge is not None: | |
| charge.use(local.used, "kernel_evaluation") | |
| return local.used | |
| def semantic_certificate(p: Problem, h: Mat, f: Mat, m: Meter, | |
| cross: bool = True) -> bool: | |
| """Check partial K + K partial = f - Q f Q for an arbitrary End task.""" | |
| lhs = add(differential(p, K(p, h, f, m, cross), m), | |
| K(p, h, differential(p, f, m), m, cross), m) | |
| rhs = add(f, mul(mul(p.Q, f, m), p.Q, m), m) | |
| return equal(lhs, rhs, m) | |