Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
recursive-self-improvement
autonomous-learning
formal-power-series
exact-arithmetic
certified-compilation
reproducible-research
| """Different exact learning/control flows sharing only an arithmetic contract.""" | |
| from __future__ import annotations | |
| import numpy as np | |
| from arithmetic import P, inv_scalar | |
| def padded(a, n): | |
| out = np.zeros(n, dtype=np.int64) | |
| out[:min(n, len(a))] = a[:n] | |
| return out | |
| def reciprocal(f, n, k): | |
| """Learn the causal inverse filter g: f*g = 1 modulo x**n.""" | |
| if not 1 <= n <= 4096 or len(f) < n: | |
| raise ValueError('Invalid precision/input') | |
| g = np.array([inv_scalar(int(f[0]), k)], dtype=np.int64) | |
| while len(g) < n: | |
| m = min(2*len(g), n) | |
| fg = padded(k.mul(f[:m], g)[:m], m) | |
| correction = (-fg) % P | |
| correction[0] = (correction[0]+2) % P | |
| k.meter.add += m+1 | |
| g = k.mul(g, correction)[:m] | |
| return g | |
| def derivative(f, k): | |
| if len(f) < 2: | |
| return np.zeros(1, dtype=np.int64) | |
| k.meter.mul += len(f)-1 | |
| return f[1:]*np.arange(1, len(f), dtype=np.int64) % P | |
| def integral(f, n, k): | |
| if n >= P: | |
| raise ValueError('Integration needs invertible coefficient indices') | |
| out = np.zeros(n, dtype=np.int64) | |
| for i in range(1, min(n, len(f)+1)): | |
| out[i] = int(f[i-1])*inv_scalar(i, k) % P | |
| k.meter.mul += 1 | |
| return out | |
| def logarithm(g, n, k): | |
| if int(g[0]) != 1: | |
| raise ValueError('Formal logarithm requires constant one') | |
| gg = padded(g, n) | |
| ratio = k.mul(derivative(gg, k), reciprocal(gg, n, k))[:n-1] | |
| return integral(ratio, n, k) | |
| def exponential(f, n, k): | |
| """Learn a solution of g'=f'g, g(0)=1, by Newton lifting.""" | |
| if int(f[0]) != 0 or n >= P: | |
| raise ValueError('Invalid formal-exponential contract') | |
| g = np.ones(1, dtype=np.int64) | |
| while len(g) < n: | |
| m = min(2*len(g), n) | |
| correction = (f[:m]-logarithm(g, m, k)) % P | |
| correction[0] = (correction[0]+1) % P | |
| k.meter.add += m+1 | |
| g = k.mul(g, correction)[:m] | |
| return g | |
| def composition(f, g, n, k): | |
| if int(g[0]) != 0: | |
| raise ValueError('Truncated composition requires inner constant zero') | |
| z = np.zeros(n, dtype=np.int64) | |
| for a in reversed(f): | |
| z = padded(k.mul(z, g)[:n], n) | |
| z[0] = (z[0]+int(a)) % P | |
| k.meter.add += 1 | |
| return z | |
| def reversion(f, n, k): | |
| """Learn a local inverse map: f(g(x))=x modulo x**n.""" | |
| if len(f) < 2 or int(f[0]) != 0 or int(f[1]) != 1: | |
| raise ValueError('Reversion requires f(0)=0 and f\'(0)=1') | |
| if n < 2: | |
| return np.zeros(n, dtype=np.int64) | |
| g = np.array([0, 1], dtype=np.int64) | |
| df = derivative(f, k) | |
| while len(g) < n: | |
| m = min(2*len(g)-1, n) | |
| gg = padded(g, m) | |
| r = composition(f, gg, m, k) | |
| r[1] = (r[1]-1) % P | |
| k.meter.add += 1 | |
| jac = composition(df, gg, m, k) | |
| delta = k.mul(r, reciprocal(jac, m, k))[:m] | |
| g = (gg-delta) % P | |
| k.meter.add += m | |
| return g | |
| def catalan(n, k): | |
| """Learn the implicit solution y=1+x*y**2; a nonlinear task family.""" | |
| g = np.ones(1, dtype=np.int64) | |
| while len(g) < n: | |
| m = min(2*len(g), n) | |
| gg = padded(g, m) | |
| square = k.mul(gg, gg)[:m-1] | |
| r = gg.copy() | |
| r[0] = (r[0]-1) % P | |
| r[1:] = (r[1:]-square) % P | |
| jac = np.zeros(m, dtype=np.int64) | |
| jac[0] = 1 | |
| jac[1:] = (-2*gg[:-1]) % P | |
| k.meter.add += m | |
| k.meter.mul += m-1 | |
| delta = k.mul(r, reciprocal(jac, m, k))[:m] | |
| g = (gg-delta) % P | |
| k.meter.add += m | |
| return g | |
| def reference_reciprocal(f, n): | |
| """Independent O(n^2) coefficient recurrence; never calls Kernel.""" | |
| g = [pow(int(f[0]), P-2, P)] | |
| for t in range(1, n): | |
| g.append(-g[0]*sum(int(f[j])*g[t-j] for j in range(1, t+1)) % P) | |
| return np.array(g, dtype=np.int64) | |
| def reference_exp(f, n): | |
| g = [1] | |
| for t in range(1, n): | |
| g.append(sum(j*int(f[j])*g[t-j] for j in range(1, t+1)) * | |
| pow(t, P-2, P) % P) | |
| return np.array(g, dtype=np.int64) | |
| def reference_catalan(n): | |
| g = [1] | |
| for t in range(1, n): | |
| g.append(sum(g[j]*g[t-1-j] for j in range(t)) % P) | |
| return np.array(g, dtype=np.int64) | |