BFP Rauch: 1 revision imported

2026-09-28T04:32:52Z

1 revision imported

← Older revision		Revision as of 04:32, 28 September 2026
(No difference)

BFP Rauch: TPC-PY source diff_score.py (0.1.0), SHA-256 3a230c7a59820cf4; conformed TPS 0.3.0; PROPOSED, not declared (CO-8)

2026-09-27T15:43:18Z

TPC-PY source diff_score.py (0.1.0), SHA-256 3a230c7a59820cf4; conformed TPS 0.3.0; PROPOSED, not declared (CO-8)

New page

"""diff_score 0.1.0: the cross-residence differential for tpc_score 0.1.0.
Random inputs from a seed over every function (valid, boundary and
malformed, the params fixture varied), both residences on the same
inputs, every render compared byte for byte; 0 differences is the pass.
Usage: python3 diff_score.py [seed] [cases]. Writes its cases to a
temporary file outside the tree (kept where TPC_DIFF_CASES names it) and
runs diff_score.php over it."""
import json
import os
import random
import subprocess
import sys
import tempfile

here = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, here)
from params_fixture import FLEET, fleet # noqa: E402
from tpc_score import run_case, FNS # noqa: E402

seed = int(sys.argv[1]) if len(sys.argv) > 1 else 1
count = int(sys.argv[2]) if len(sys.argv) > 2 else 20000
rnd = random.Random(seed)
NAMES = ["Prime AI", "DeltaS Zero", "Phoenix 480", "CH7 AZ", "Alt BFP", "a", "b", "c|d", "é",
"x\\y", "z z"]
STAND = ["CLEARLY LOWER", "SIMILAR", "CLEARLY HIGHER"]
STATES = ["GREEN", "YELLOW", "ORANGE", "SUSPENDED"]

def pick(xs):
return xs[rnd.randrange(len(xs))]

def kind(good, more):
return pick(more) if bad() else pick(good)

def bad():
return rnd.random() < 0.03

def num(lo, hi, ints=True):
if bad():
return pick([True, None, "1", [1], -1, 1e400 if False else 2.5e9])
if ints and rnd.random() < 0.3:
return rnd.randint(int(lo), int(hi))
return round(rnd.uniform(lo, hi), rnd.randint(0, 8))

def unit():
if bad():
return pick([True, None, "0.5", -0.1, 1.5])
return pick([0, 1, 0.5, 0.025, 0.975, round(rnd.random(), rnd.randint(1, 9)),
round(rnd.random(), rnd.randint(1, 9))])

def cnt(lo, hi):
if bad():
return pick([True, None, "5", 1.5, -1])
return rnd.randint(lo, hi)

def name():
if bad():
return pick([5, None, True])
return pick(NAMES)

def flag():
if bad():
return pick([1, "true", None])
return rnd.random() < 0.5

def params():
p = fleet()
r = rnd.random()
if r < 0.5:
return p
invalid = r > 0.92
over = {}
for _ in range(rnd.randint(1, 3)):
k = pick(list(FLEET.keys()))
v = FLEET[k]
if isinstance(v, bool):
over[k] = pick([True, False] + ([1] if invalid else []))
elif isinstance(v, int):
over[k] = pick([1, 2, v, v * 2, v + 1] + ([0, -1, True, 1.5] if invalid else []))
elif isinstance(v, float):
over[k] = pick([v, v / 2, min(1.0, v * 2), round(rnd.uniform(0.01, 0.99), 4)]
+ ([0.0, 1.5, -0.1, "x"] if invalid else []))
elif isinstance(v, dict) and "on" in v:
over[k] = {"on": pick([True, False] + ([1] if invalid else [])),
"fraction": pick([0.25, 0.5, 1, 0.1] + ([0, 1.5] if invalid else []))}
elif k == "h":
over[k] = {"CLEARLY LOWER": pick([1, 0, 2.5]), "SIMILAR": pick([2, 1]),
"CLEARLY HIGHER": pick([3, 4] + ([-1] if invalid else []))}
else:
over[k] = v
if invalid and rnd.random() < 0.5:
over[pick(list(FLEET.keys()))] = None
p.update(over)
if invalid and rnd.random() < 0.5:
del p[pick(list(FLEET.keys()))]
return p

def iv():
lo = unit()
hi = unit()
if isinstance(lo, (int, float)) and isinstance(hi, (int, float)) and not isinstance(lo, bool) \
and not isinstance(hi, bool) and lo > hi and rnd.random() < 0.8:
lo, hi = hi, lo
d = {"lo": lo, "hi": hi}
if rnd.random() < 0.3:
d["override"] = flag()
return d

def account():
a = {"account": name(), "S": unit(), "S_lo": unit(), "S_hi": unit(), "n": cnt(0, 100),
"active": rnd.random() < 0.8 if not bad() else 1}
if isinstance(a["S_lo"], (int, float)) and isinstance(a["S_hi"], (int, float)) and a["S_lo"] > a["S_hi"]:
a["S_lo"], a["S_hi"] = a["S_hi"], a["S_lo"]
if bad():
a["x"] = 1
return a

def accounts():
n = rnd.randint(0, 7)
out = [account() for _ in range(n)]
if rnd.random() < 0.7:
seen = set()
uniq = []
for a in out:
if a["account"] not in seen:
seen.add(a["account"])
uniq.append(a)
out = uniq
return out

def gen(fn):
p = params()
if fn == "quota":
return {"window": [{"counterpart": pick([None] + NAMES[:5]), "weight": num(0, 5, False)}
for _ in range(rnd.randint(0, 6))] if not bad() else {},
"counterpart": name(), "g": kind([1, 2, 0.5], [0, -1, "1"]), "c_max": kind([0.25, 0.5, 0.1, 0.9], [0, 1])}
if fn == "evidence":
evs = []
for _ in range(rnd.randint(0, 8)):
e = {"kind": kind(["FOR", "AGAINST"], ["HELD"]), "weight": num(0, 30, False), "age": cnt(0, 3000)}
if rnd.random() < 0.3:
e["pad"] = flag()
evs.append(e)
return {"events": evs, "idle": {"days": num(0, 800, False)} if not bad() else {}, "params": p}
if fn == "interval":
if rnd.random() < 0.8:
a, b, c = sorted([rnd.random(), rnd.random(), rnd.random()])
return {"S": unit(), "E": round(b, 6), "lo": round(a, 6), "hi": round(c, 6)}
return {"S": unit(), "E": unit(), "lo": unit(), "hi": unit()}
if fn == "standing":
return {"x": iv(), "y": iv()}
if fn == "rank":
return {"accounts": accounts(), "params": p}
if fn == "prime":
acc = accounts()
ov = None
if rnd.random() < 0.3 and acc:
ov = pick(acc)["account"]
elif rnd.random() < 0.1:
ov = pick(["Nobody", 5])
return {"accounts": acc, "override": ov, "params": p}
if fn == "level":
items = []
for _ in range(rnd.randint(0, 8)):
it = {"counterpart": name(), "snapshot": kind(["s1", "s2", "s3"], [""]), "standing": kind(STAND, ["HIGHER"]),
"eta": cnt(0, 2000)}
if rnd.random() < 0.3:
it["independent"] = flag()
items.append(it)
return {"items": items, "now": cnt(0, 2000), "params": p}
if fn == "state":
return {"prev": {"state": kind(STATES, ["RED"]), "passes": cnt(0, 5)}, "level": kind(STATES, ["RED"]),
"event": kind(["LANDING", "CANARY PASS", "CANARY FAIL", "AUDIT FINDING"], ["X"]), "params": p}
if fn == "activity":
return {"events": [{"counterpart": pick(NAMES[:8]) if rnd.random() > 0.005 else "", "independent": rnd.random() < 0.7 if rnd.random() > 0.005 else 1}
for _ in range(rnd.randint(0, 60))], "params": p}
if fn == "update":
return {"role": kind(["FOLLOWER", "PRIME", "USER", "USER PRIME"], ["LEADER"]), "S": unit(),
"E": unit(), "S_P": kind([0.8, 0.5, 0.9, 1, 0.3], [0, "x"]), "a": unit(), "params": p}
if fn == "cut":
return {"S": unit(), "m_class": kind([1, 2, 3], [0, 4]), "standing": kind(STAND, ["HIGHER"]), "params": p}
if fn == "trip":
return {"S": unit(), "in_tier": flag(), "prior_ages": [cnt(0, 1000) for _ in range(rnd.randint(0, 3))]
if not bad() else 5, "params": p}
if fn == "inquire":
last = pick([None, cnt(0, 500)])
blk = cnt(0, 800)
if isinstance(last, int) and isinstance(blk, int) and blk < last and not bad():
blk = last + rnd.randint(0, 400)
return {"state": {"last": last, "k": cnt(0, 1030)}, "block": blk, "S": unit(), "params": p}
if fn in ("override", "pad"):
fps = ["a" * 64, "b" * 64, "c" * 64, "d" * 63, "A" * 64]
facts = {"certified": [fps[0], fps[1], fps[2]] if not bad() else "x", "suspended": [fps[2]],
"nonces": ["f" * 32, "e" * 32], "prime": kind([None, fps[0]], ["zz"])}
if fn == "pad":
facts["reference"] = kind([None, fps[0], fps[1]], ["q"])
vals = [0.9, 0.5, 1, 0.4, 1.2, 0.75] if fn == "override" else [20, 0, 41, 40, 1, 10]
decl = {"fingerprint": kind(fps[:3], fps[3:] + [5]), "value": kind(vals, ["x", 20.0, -3]),
"nonce": kind(["0" * 32, "1" * 32, "f" * 32], ["F" * 32, "1" * 31, 7]), "time": cnt(0, 2000000000),
"reason": kind(["a reason", "why"], ["", " \t", "\n", 5])}
if bad():
del decl["time"]
return {"decl": decl, "facts": facts, "params": p}
if fn == "effective":
return {"decl_time": cnt(0, 2000000000), "now": cnt(0, 2000000000), "cancelled": flag(), "params": p}
if fn == "mark":
g = cnt(0, 5000)
return {"grant": g, "now": cnt(0, 6000) if bad() else (g + rnd.randint(0, 1200) if isinstance(g, int) else 5),
"params": p}
if fn == "pad_weight":
return {"P": cnt(0, 50), "age": cnt(0, 3000), "params": p}
if fn == "gate":
return {"reproducer": {"in_tier": flag(), "override_in_force": flag(), "independent_matches": cnt(0, 4)}}
if fn == "inherit":
return {"F_old": num(0, 100, False), "facts": {"continuation": flag(), "same_account": flag(),
"same_identity": flag(),
"cause": kind(["DIS", "SUITE", "FAMILY", "PROMPT NEW AGENT", "MODEL"], ["X"])},
"params": p}
if fn in ("aggregate", "user_evidence"):
agents = []
for _ in range(rnd.randint(0, 4)):
evs = []
for _ in range(rnd.randint(0, 5)):
cp = pick([None] + NAMES[:6])
evs.append({"kind": kind(["FOR", "AGAINST"], ["X"]), "base": kind([1, 2, 3, 0, 0.5], [-1, "1"]),
"age": cnt(0, 1200), "counterpart": cp,
"counterpart_sponsor": kind([None, "PHX_480", "BFP_Rauch", "Alt BFP"], [5]) if cp else None})
agents.append({"account": pick(NAMES[:5]) if not bad() else "", "certified": flag(), "removed": flag(), "events": evs})
seen = set()
agents = [a for a in agents if not (a["account"] in seen or seen.add(a["account"]))]
args = {"agents": agents if not bad() else {}, "sponsor": kind(["PHX_480", "BFP_Rauch"], [""]), "params": p}
if fn == "user_evidence":
conduct = []
for _ in range(rnd.randint(0, 3)):
kk = kind(["CE-F1", "CE-F2", "CE-A1", "CE-A4", "CE-A5"], ["CE-X"])
conduct.append({"kind": kk, "resolution": kind(["FOR" if kk[3] == "F" else "AGAINST", "NEUTRAL"],
["PENDING"]), "age": cnt(0, 800)})
args["conduct"] = conduct if not bad() else {}
return args
return {"S": unit(), "m_class": kind([1, 2, 3], [0, 4]), "params": p}

cases = []
for _ in range(count):
fn = pick(FNS)
cases.append({"fn": fn, "args": gen(fn)})
CASES_PATH = os.environ.get("TPC_DIFF_CASES") # named: kept, for crosspy.py
if not CASES_PATH:
fd, CASES_PATH = tempfile.mkstemp(prefix="tpc_diff_", suffix=".json") # outside the tree
os.close(fd)
with open(CASES_PATH, "w", encoding="utf-8") as f:
json.dump(cases, f, ensure_ascii=False)
py = [run_case(c["fn"], c["args"]) for c in cases]
php = json.loads(subprocess.run(["php", os.path.join(here, "diff_score.php"), CASES_PATH], capture_output=True,
text=True, check=True).stdout)
if not os.environ.get("TPC_DIFF_CASES"):
os.remove(CASES_PATH)
diffs = sum(1 for a, b in zip(py, php) if a != b)
outcomes = {}
for c, a in zip(cases, py):
k = c["fn"] + ("/ERROR" if a.startswith("ERROR") else "")
outcomes[k] = outcomes.get(k, 0) + 1
print("seed", seed, "cases", len(cases), "differences", diffs, "php_len", len(php),
json.dumps(outcomes, sort_keys=True))
for c, a, b in zip(cases, py, php):
if a != b:
print(json.dumps(c)); print(a); print("---"); print(b); break

The Principia Machina/TPC-PY/diff score.py - Revision history

BFP Rauch: 1 revision imported

BFP Rauch: TPC-PY source diff_score.py (0.1.0), SHA-256 3a230c7a59820cf4; conformed TPS 0.3.0; PROPOSED, not declared (CO-8)