Datasets:
Formats:
csv
Languages:
English
Size:
10K - 100K
Tags:
recursive-self-improvement
symmetry-reduction
finite-groups
exact-compilation
dynamic-programming
reproducible-research
| """Neyaru minimal exact core. Python 3.10+, standard library only. | |
| Run: python3 reference_core.py | |
| The benchmark implementation is separate and reports full overhead. | |
| """ | |
| from dataclasses import dataclass | |
| from math import inf | |
| class Dihedral: | |
| """Elements r**a s**b encoded a + m*b; group order is 2*m.""" | |
| def __init__(self, m): | |
| self.m, self.n = m, 2*m | |
| self.mul = [[((a % m) + (1 if a < m else -1)*(b % m)) % m | |
| + m*((a // m) ^ (b // m)) | |
| for b in range(2*m)] for a in range(2*m)] | |
| self.inv = [next(b for b in range(self.n) | |
| if self.mul[a][b] == 0) for a in range(self.n)] | |
| def closure(self, generators): | |
| found, queue = {0}, [0] | |
| for a in queue: | |
| for b in generators: | |
| c = self.mul[a][b] | |
| if c not in found: | |
| found.add(c) | |
| queue.append(c) | |
| return found | |
| def stabilizer(G, values, left): | |
| """Rare-value filter, exact tests, and certified subgroup closure.""" | |
| buckets = {} | |
| for x, v in enumerate(values): | |
| buckets.setdefault(v, []).append(x) | |
| if len(buckets) == 1: | |
| return frozenset(range(G.n)) | |
| bucket = min(buckets.values(), key=len) | |
| anchor = bucket[0] | |
| candidates = [(G.mul[y][G.inv[anchor]] if left else | |
| G.mul[G.inv[anchor]][y]) for y in bucket] | |
| known, generators = {0}, [] | |
| for a in sorted(candidates): | |
| if a in known: | |
| continue | |
| if all(values[G.mul[a][x] if left else G.mul[x][a]] == values[x] | |
| for x in range(G.n)): | |
| generators.append(a) | |
| known = G.closure(generators) | |
| return frozenset(known) | |
| class Kernel: | |
| values: tuple | |
| L: frozenset | |
| R: frozenset | |
| leaf: str = "" | |
| children: object = None | |
| choices: object = None | |
| def witness(self, boundary): | |
| if self.values[boundary] == inf: | |
| raise ValueError("infeasible boundary") | |
| if self.children is None: | |
| return [(self.leaf, boundary, self.values[boundary])] | |
| a, b = self.choices[boundary] | |
| u, v = self.children | |
| return u.witness(a) + v.witness(b) | |
| def leaf(G, name, values): | |
| values = tuple(values) | |
| return Kernel(values, stabilizer(G, values, True), | |
| stabilizer(G, values, False), leaf=name) | |
| def compose(G, f, g, quotient=True, learn=True): | |
| """All role occurrences remain in the witness DAG. | |
| pairs counts only objective candidates, not total runtime. | |
| Complete symmetry and orbit costs are charged in the benchmark. | |
| """ | |
| if quotient: | |
| H = f.R & g.L | |
| inner, covered = [], set() | |
| for a in range(G.n): | |
| if a not in covered: | |
| inner.append(a) | |
| covered.update(G.mul[a][h] for h in H) | |
| orbits, covered = [], set() | |
| for z in range(G.n): | |
| if z in covered: | |
| continue | |
| orbit = {} | |
| for l in sorted(f.L): | |
| for r in sorted(g.R): | |
| x = G.mul[G.mul[l][z]][r] | |
| orbit.setdefault(x, (l, r)) | |
| covered.update(orbit) | |
| orbits.append((z, orbit)) | |
| else: | |
| inner = list(range(G.n)) | |
| orbits = [(z, {z: (0, 0)}) for z in range(G.n)] | |
| values, choices, pairs = [inf]*G.n, [None]*G.n, 0 | |
| for z, orbit in orbits: | |
| best, arg = inf, None | |
| for a in inner: | |
| b = G.mul[G.inv[a]][z] | |
| score = f.values[a] + g.values[b] | |
| pairs += 1 | |
| if score < best: | |
| best, arg = score, (a, b) | |
| for x, (l, r) in orbit.items(): | |
| values[x] = best | |
| if arg is not None: | |
| a, b = arg | |
| # Retrieve child witnesses at NEW boundaries. Never edit | |
| # a primitive choice merely because aggregate costs agree. | |
| choices[x] = (G.mul[l][a], G.mul[b][r]) | |
| values = tuple(values) | |
| L = stabilizer(G, values, True) if learn else f.L | |
| R = stabilizer(G, values, False) if learn else g.R | |
| out = Kernel(values, L, R, children=(f, g), choices=choices) | |
| for x, pair in enumerate(choices): | |
| if pair is not None: | |
| a, b = pair | |
| assert G.mul[a][b] == x | |
| assert f.values[a] + g.values[b] == values[x] | |
| return out, pairs | |
| def verify_witness(G, kernel, boundary): | |
| # Enumerated positions distinguish repeated occurrences of a leaf type. | |
| product, cost = 0, 0 | |
| for position, (leaf_type, action, action_cost) in enumerate( | |
| kernel.witness(boundary)): | |
| assert position >= 0 and leaf_type | |
| product = G.mul[product][action] | |
| cost += action_cost | |
| assert product == boundary and cost == kernel.values[boundary] | |
| def demo(): | |
| G = Dihedral(16) | |
| c, M = 3, 19 | |
| def seed(j): | |
| step, size = G.m // (2**j), 2**j | |
| values = [M]*G.n | |
| for a in range(size//2 + 1): | |
| values[(a*step) % G.m] = 0 | |
| values[G.m] = c | |
| return leaf(G, "f" + str(j), values) | |
| h, _ = compose(G, seed(1), seed(1)) | |
| print("level |L| |R| quotient_pairs dense_pairs") | |
| for j in range(2, 5): | |
| f = seed(j) | |
| nxt, reduced_pairs = compose(G, h, f) | |
| dense, dense_pairs = compose(G, h, f, quotient=False, learn=False) | |
| assert nxt.values == dense.values and nxt.values != h.values | |
| expected_K = {a*(G.m//(2**j)) for a in range(2**j)} | |
| assert set(nxt.L) == expected_K == set(nxt.R) | |
| for boundary in range(G.n): | |
| verify_witness(G, nxt, boundary) | |
| print(j, len(nxt.L), len(nxt.R), reduced_pairs, dense_pairs) | |
| # Newly learned metadata changes the NEXT composition procedure. | |
| h = nxt | |
| assert h.values == tuple([0]*G.m + [c]*G.m) | |
| print("Exact table equality, new-kernel growth, and witnesses passed.") | |
| print("Pair counts exclude discovery/orbit overhead; see benchmark.") | |
| if __name__ == "__main__": | |
| demo() | |