Datasets:
Formats:
csv
Languages:
English
Size:
< 1K
Tags:
recursive-self-improvement
meta-learning
learned-optimizers
homological-algebra
formal-methods
synthetic-data
File size: 5,242 Bytes
33f388b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | """Exact finite counterexample: cheaper repair need not be a better improver.
Python 3.10+, standard library only. Run from the research directory:
python3 src/verify_pair.py --out results/pair_counterexample.json
Enumerates every degree -1 singleton proposal and every matrix-unit input to
the pair's higher-homotopy identity. No sampled trials or floating-point algebra.
"""
from __future__ import annotations
import argparse
from fractions import Fraction
import json
from pathlib import Path
from core import (Meter, Problem, add, differential, K, mul, nnz, positions,
repaired_candidate, valid)
def example():
names = ("x", "u", "b", "c", "v", "y", "w")
x, u, b, c, v, y, w = range(7)
d = [0] * 7
d[b] = 1 << x
d[y] = 1 << c
h0 = [0] * 7
h0[x] = 1 << b
h0[c] = 1 << y
h1 = [0] * 7
h1[x] = (1 << b) | (1 << c)
h1[c] = 1 << y
h1[b] = 1 << y
Q = tuple(1 << j if j in (u, v, w) else 0 for j in range(7))
P = tuple((1 << j) ^ Q[j] for j in range(7))
problem = Problem(tuple(d), Q, P, tuple(h0), (0, 0, 1, 1, 1, 2, 2))
return problem, tuple(h0), tuple(h1), names
def verify():
p, work, generator, names = example()
assert valid(p, work, Meter())
assert valid(p, generator, Meter())
# B = w*g; partial B = g-w (minus equals plus over GF(2)).
B = mul(work, generator, Meter())
assert differential(p, B, Meter()) == add(generator, work, Meter())
def L(f):
m = Meter()
return add(mul(B, f, m), mul(mul(p.Q, f, m), B, m), m)
verified_units = 0
for i in range(p.n):
for j in range(p.n):
f = [0] * p.n
f[i] = 1 << j
f = tuple(f)
m = Meter()
lhs = add(K(p, generator, f, m), K(p, work, f, m), m)
rhs = add(differential(p, L(f), m), L(differential(p, f, m)), m)
assert lhs == rhs
verified_units += 1
available = positions(p, -1, Meter())
records = []
for label, gen in (("sparse_h0", work), ("denser_h1", generator)):
trials = []
for i, j in available:
a = [0] * p.n
a[i] = 1 << j
meter = Meter()
child = repaired_candidate(p, generator, gen, tuple(a), meter)
is_valid = valid(p, child, meter)
score = nnz(child, meter)
success = child == work
assert is_valid
assert success or child == generator
trials.append({"proposal": f"{names[j]}->{names[i]}",
"success": success, "valid": is_valid,
"child_nnz": score,
"candidate_check_score_work": meter.used})
successes = sum(t["success"] for t in trials)
probability = Fraction(successes, len(trials))
mean_cost = Fraction(sum(t["candidate_check_score_work"]
for t in trials), len(trials))
proposal_cost = p.n + 7
records.append({
"generator": label,
"generator_nnz": nnz(gen, Meter()),
"successes": successes,
"proposal_count": len(trials),
"success_probability_exact": str(probability),
"mean_candidate_check_score_work_exact": str(mean_cost),
"expected_discovery_work_excluding_setup_and_proposal_exact":
str(mean_cost / probability),
"common_proposal_cost": proposal_cost,
"expected_discovery_work_including_proposal_excluding_setup_exact":
str((mean_cost + proposal_cost) / probability),
"trials": trials,
})
assert records[0]["successes"] == 1
assert records[1]["successes"] == 2
return {
"field": "GF(2)", "dimension": p.n, "names": names,
"grades": p.grades,
"scope": "exact finite counterexample, not a broad benchmark",
"fixed_child": "h1",
"pair_witness_nonzero_entries": ["y->x"],
"pair_witness_orientation": "B = work * generator; partial B = generator - work",
"pair_witness_verified": True,
"higher_homotopy_basis_checks": verified_units,
"cost_warning": "Expected work excludes discovery/selection of the "
"generator and one-time setup. Meter costs are not "
"hardware timings. All parent/pair costs must be "
"charged in a comparative RSI experiment.",
"results": records,
}
if __name__ == "__main__":
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--out", default="results/pair_counterexample.json")
args = parser.parse_args()
result = verify()
out = Path(args.out)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
print(json.dumps({"output": str(out), "pair_witness_verified": True,
"higher_homotopy_basis_checks":
result["higher_homotopy_basis_checks"],
"success_probabilities":
[r["success_probability_exact"]
for r in result["results"]]}, indent=2))
|