Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
recursive-self-improvement
autonomous-learning
formal-power-series
exact-arithmetic
certified-compilation
reproducible-research
| """Exact polynomial arithmetic, explicit cost vectors, and certified programs. | |
| The field is F_65537. NumPy computes exact int64 schoolbook convolutions; | |
| the configured size bound prevents integer overflow before modular reduction. | |
| Field-operation counts model arithmetic, not machine instructions or time. | |
| """ | |
| from __future__ import annotations | |
| from dataclasses import dataclass, asdict | |
| from collections import Counter | |
| import numpy as np | |
| from synthesis import verify_tensor, linear_adds, digest | |
| P = 65537 | |
| MAX_LENGTH = 8192 | |
| class Meter: | |
| add: int = 0 | |
| mul: int = 0 | |
| calls: int = 0 | |
| plan_states: int = 0 | |
| certificate_ops: int = 0 | |
| allocations: int = 0 | |
| def snapshot(self): | |
| d = asdict(self) | |
| d['field_ops'] = self.add + self.mul | |
| # Declared abstract ledger, not a measured instruction count. | |
| d['ledger_units'] = (self.add + self.mul + self.calls + | |
| 32*self.plan_states + self.certificate_ops) | |
| return d | |
| def validate(a): | |
| a = np.asarray(a, dtype=np.int64) | |
| if a.ndim != 1 or len(a) < 1 or len(a) > MAX_LENGTH: | |
| raise ValueError('Polynomial lengths must be in [1, 8192]') | |
| if np.any(a < 0) or np.any(a >= P): | |
| raise ValueError('Coefficients must be canonical residues modulo 65537') | |
| return a | |
| def base_cost(n, m): | |
| return n*m, n*m - (n+m-1) | |
| class Kernel: | |
| """Interprets a finite, proof-carrying, depth-bounded arithmetic program. | |
| Every available program includes the schoolbook fallback. Selection is by | |
| exact dense field-operation cost, independent of coefficient values. | |
| """ | |
| def __init__(self, law, cap=0): | |
| if type(cap) is not int or not 0 <= cap <= 20: | |
| raise ValueError('Invalid program depth') | |
| ok, work = verify_tensor(law) | |
| if not ok: | |
| raise ValueError('Rejected unsound bilinear tensor certificate') | |
| self.law = law | |
| self.cap = cap | |
| self.meter = Meter(certificate_ops=work) | |
| self.plans = {} | |
| self.trace = Counter() | |
| self.input_adds = sum(linear_adds(r) for r in law['A']+law['B']) | |
| self.output_adds = sum(linear_adds(r) for r in law['C']) | |
| def plan(self, n, m, cap=None): | |
| cap = self.cap if cap is None else cap | |
| key = (n, m, cap) | |
| if key in self.plans: | |
| return self.plans[key] | |
| self.meter.plan_states += 1 | |
| bm, ba = base_cost(n, m) | |
| best = (bm, ba, 0) | |
| if cap > 0 and max(n, m) > 1 and min(n, m) > 1: | |
| h = (max(n, m)+1)//2 | |
| cm, ca, _ = self.plan(h, h, cap-1) | |
| overhead = self.input_adds*h + (self.output_adds+2)*(2*h-1) | |
| candidate = (3*cm, 3*ca+overhead, 1) | |
| if candidate[0]+candidate[1] < bm+ba: | |
| best = candidate | |
| # A longer operand is split without permuting coefficient order. | |
| # This repairs the padding penalty on 2:1 Newton-lifting products. | |
| if max(n, m) >= 2*min(n, m): | |
| h = max(n, m)//2 | |
| if n >= m: | |
| x = self.plan(h, m, cap) | |
| y = self.plan(n-h, m, cap) | |
| extra = n-h+m-1 | |
| else: | |
| x = self.plan(n, h, cap) | |
| y = self.plan(n, m-h, cap) | |
| extra = n+m-h-1 | |
| rectangular = (x[0]+y[0], x[1]+y[1]+extra, 2) | |
| if sum(rectangular[:2]) < sum(best[:2]): | |
| best = rectangular | |
| self.plans[key] = best | |
| return best | |
| def cost(self, n, m): | |
| a, b, _ = self.plan(n, m) | |
| return a+b | |
| def _lin(self, arrays, row): | |
| nz = [(a, c) for a, c in zip(arrays, row) if c] | |
| if not nz: | |
| return np.zeros(len(arrays[0]), dtype=np.int64) | |
| a, c = nz[0] | |
| z = a.copy() | |
| self.meter.allocations += len(z) | |
| if c == -1: | |
| z = (-z) % P | |
| self.meter.add += len(z) | |
| for a, c in nz[1:]: | |
| z = (z + a) % P if c == 1 else (z - a) % P | |
| self.meter.add += len(z) | |
| return z | |
| def _mul(self, a, b, cap): | |
| n, m = len(a), len(b) | |
| self.meter.calls += 1 | |
| _, _, split = self.plan(n, m, cap) | |
| if not split: | |
| cm, ca = base_cost(n, m) | |
| self.meter.mul += cm | |
| self.meter.add += ca | |
| self.meter.allocations += n+m-1 | |
| # max coefficient sum <= 8192 * 65536**2 < 2**63. | |
| return np.convolve(a, b) % P | |
| if split == 2: | |
| h = max(n, m)//2 | |
| if n >= m: | |
| left = self._mul(a[:h], b, cap) | |
| right = self._mul(a[h:], b, cap) | |
| else: | |
| left = self._mul(a, b[:h], cap) | |
| right = self._mul(a, b[h:], cap) | |
| out = np.zeros(n+m-1, dtype=np.int64) | |
| out[:len(left)] = left | |
| out[h:h+len(right)] = (out[h:h+len(right)]+right) % P | |
| self.meter.add += len(right) | |
| self.meter.allocations += len(out) | |
| return out | |
| h = (max(n, m)+1)//2 | |
| aa = np.pad(a, (0, 2*h-n)) | |
| bb = np.pad(b, (0, 2*h-m)) | |
| av, bv = [aa[:h], aa[h:]], [bb[:h], bb[h:]] | |
| products = [] | |
| for ar, br in zip(self.law['A'], self.law['B']): | |
| products.append(self._mul(self._lin(av, ar), | |
| self._lin(bv, br), cap-1)) | |
| c = [self._lin(products, row) for row in self.law['C']] | |
| out = np.zeros(4*h-1, dtype=np.int64) | |
| out[:2*h-1] = c[0] | |
| for k in (1, 2): | |
| sl = slice(k*h, k*h+2*h-1) | |
| out[sl] = (out[sl]+c[k]) % P | |
| self.meter.add += 2*h-1 | |
| self.meter.allocations += len(out) | |
| return out[:n+m-1] | |
| def mul(self, a, b): | |
| a, b = validate(a), validate(b) | |
| self.trace[(len(a), len(b))] += 1 | |
| return self._mul(a, b, self.cap) | |
| def program(self, parent=None): | |
| body = {'schema': 1, 'kind': 'certified_bilinear_envelope', | |
| 'field': P, 'cap': self.cap, 'law': self.law, | |
| 'parent_sha256': parent, 'max_length': MAX_LENGTH} | |
| return {**body, 'sha256': digest(body)} | |
| def load_program(data): | |
| if type(data) is not dict: | |
| raise ValueError('Invalid program envelope') | |
| body = {k: v for k, v in data.items() if k != 'sha256'} | |
| if digest(body) != data.get('sha256'): | |
| raise ValueError('Program integrity check failed') | |
| if body.get('field') != P or body.get('schema') != 1: | |
| raise ValueError('Unsupported program contract') | |
| if body.get('kind') != 'certified_bilinear_envelope': | |
| raise ValueError('Unsupported program language') | |
| return Kernel(body['law'], body['cap']) | |
| class NTTKernel: | |
| """Conventional cached radix-two transform baseline, not a learned program. | |
| Roots, their construction, and modular inverse powers are charged. All | |
| transforms use exact field arithmetic. Schoolbook is selected whenever | |
| its predicted field-operation count is lower than a cached NTT estimate. | |
| """ | |
| def __init__(self, law): | |
| self.meter = Meter() | |
| self.trace = Counter() | |
| self.roots = {} | |
| self.base = Kernel(law, 0) | |
| def _pow(self, a, k): | |
| y = 1 | |
| while k: | |
| if k & 1: | |
| y = y*a % P | |
| self.meter.mul += 1 | |
| k >>= 1 | |
| if k: | |
| a = a*a % P | |
| self.meter.mul += 1 | |
| return y | |
| def _roots(self, size, inverse): | |
| key = (size, inverse) | |
| if key in self.roots: | |
| return self.roots[key] | |
| w = self._pow(3, (P-1)//size) | |
| if inverse: | |
| w = self._pow(w, P-2) | |
| r = np.ones(size//2, dtype=np.int64) | |
| for j in range(1, len(r)): | |
| r[j] = r[j-1]*w % P | |
| self.meter.mul += 1 | |
| self.roots[key] = r | |
| return r | |
| def _transform(self, a, inverse=False): | |
| n = len(a) | |
| bits = n.bit_length()-1 | |
| # Integer indexing work is not included in field operation counts. | |
| rev = np.array([int(format(i, '0%db' % bits)[::-1], 2) | |
| for i in range(n)], dtype=np.int64) | |
| out = a[rev].copy() | |
| size = 2 | |
| while size <= n: | |
| r = self._roots(size, inverse) | |
| view = out.reshape(-1, size) | |
| left = view[:, :size//2].copy() | |
| right = view[:, size//2:]*r % P | |
| view[:, :size//2] = (left+right) % P | |
| view[:, size//2:] = (left-right) % P | |
| self.meter.mul += n//2 | |
| self.meter.add += n | |
| size *= 2 | |
| if inverse: | |
| inv = self._pow(n, P-2) | |
| out = out*inv % P | |
| self.meter.mul += n | |
| self.meter.allocations += n | |
| return out | |
| def mul(self, a, b): | |
| a, b = validate(a), validate(b) | |
| nout = len(a)+len(b)-1 | |
| n = 1 << (nout-1).bit_length() | |
| if n > P-1: | |
| raise ValueError('Transform exceeds field root-of-unity contract') | |
| self.trace[(len(a), len(b))] += 1 | |
| self.meter.calls += 1 | |
| bm, ba = base_cost(len(a), len(b)) | |
| estimate = (9*n*(n.bit_length()-1))//2 + 2*n | |
| if bm+ba <= estimate: | |
| self.meter.mul += bm | |
| self.meter.add += ba | |
| return np.convolve(a, b) % P | |
| aa = np.pad(a, (0, n-len(a))) | |
| bb = np.pad(b, (0, n-len(b))) | |
| c = self._transform(aa)*self._transform(bb) % P | |
| self.meter.mul += n | |
| return self._transform(c, True)[:nout] | |
| def inv_scalar(x, backend): | |
| if not x % P: | |
| raise ValueError('Constant term is not a unit') | |
| k, a, out = P-2, int(x), 1 | |
| while k: | |
| if k & 1: | |
| out = out*a % P | |
| backend.meter.mul += 1 | |
| k >>= 1 | |
| if k: | |
| a = a*a % P | |
| backend.meter.mul += 1 | |
| return out | |