254 lines
12 KiB
Python
254 lines
12 KiB
Python
"""Read-only audit of frozen proposal fixtures, not a language implementation.
|
|
|
|
Only this directory's audit-results.json is written. No parser, type checker,
|
|
numeric evaluator, package materializer or Studio admission is implemented here.
|
|
"""
|
|
|
|
import base64
|
|
import hashlib
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
import re
|
|
import sys
|
|
import uuid
|
|
|
|
|
|
HERE = Path(__file__).resolve().parent
|
|
ROOT = HERE.parents[2]
|
|
ANALYSIS = ROOT / "harness/experiments/analysis-baseline-20260911"
|
|
LIBRARY = ROOT / "harness/experiments/library-compatibility-20260911"
|
|
checks = []
|
|
|
|
|
|
def require(condition, label):
|
|
if not condition:
|
|
raise AssertionError(label)
|
|
checks.append(label)
|
|
|
|
|
|
def digest(data):
|
|
return hashlib.sha256(data).hexdigest()
|
|
|
|
|
|
def pairs_without_duplicates(pairs):
|
|
result = {}
|
|
for key, value in pairs:
|
|
if key in result:
|
|
raise ValueError(f"duplicate JSON key: {key}")
|
|
result[key] = value
|
|
return result
|
|
|
|
|
|
def read_json(path):
|
|
return json.loads(path.read_bytes(), object_pairs_hook=pairs_without_duplicates)
|
|
|
|
|
|
def walk(value):
|
|
yield value
|
|
if isinstance(value, dict):
|
|
for child in value.values():
|
|
yield from walk(child)
|
|
elif isinstance(value, list):
|
|
for child in value:
|
|
yield from walk(child)
|
|
|
|
|
|
def tree(directory):
|
|
return {p.relative_to(directory).as_posix(): p.read_bytes()
|
|
for p in directory.rglob("*") if p.is_file()}
|
|
|
|
|
|
frozen_hashes = {
|
|
"harness/release-analysis-baseline-contract-20260911.md":
|
|
"9d294a3a8ad41ef4d07caac9fa410286f22ea5464400ccf01714f76e01ba5802",
|
|
"harness/release-library-compatibility-contract-20260911.md":
|
|
"30bbfd379ec542827a22d3b604534e5b6329cd913ff243747004e1afa2983ee5",
|
|
"harness/experiments/library-compatibility-20260911/main.rs":
|
|
"bc31bacf250f3711758717f18a3104696ed941c3c9b89817caa6a96e6540062a",
|
|
"harness/experiments/library-compatibility-20260911/EVIDENCE.json":
|
|
"1eb643f20645a83e88e644b1f2c42d554f35259fa2cfceafa0632bf47c2ed966",
|
|
}
|
|
for name, expected in frozen_hashes.items():
|
|
require(digest((ROOT / name).read_bytes()) == expected, f"frozen hash: {name}")
|
|
|
|
analysis_files = tree(ANALYSIS)
|
|
require(len(analysis_files) == 11, "exactly 11 baseline fixture files")
|
|
for name in analysis_files:
|
|
if ".json" in name:
|
|
read_json(ANALYSIS / name)
|
|
checks.append(f"strict JSON transport: {name}")
|
|
|
|
portable_bytes = (ANALYSIS / "portable-document.json.proposed").read_bytes()
|
|
portable = read_json(ANALYSIS / "portable-document.json.proposed")
|
|
frozen = read_json(ANALYSIS / "freeze-degraded.json.proposed")
|
|
integrity = read_json(ANALYSIS / "fixture-integrity.json")
|
|
source_bytes = (ANALYSIS / "active.arcadia.proposed").read_bytes()
|
|
source = source_bytes.decode("utf-8")
|
|
require(portable["source"]["entry"] == "active.arcadia", "declared source entry")
|
|
require(portable["source"]["files"] == {"active.arcadia": source}, "exact embedded source bytes")
|
|
require(len(source_bytes) == integrity["source_utf8_bytes"] == 2678, "source byte count")
|
|
require(len(source.splitlines()) == integrity["source_lines"] == 55, "source line count")
|
|
capsule = frozen["captured_document"]
|
|
require(base64.b64decode(capsule["bytes_base64"], validate=True) == portable_bytes,
|
|
"freeze capsule is byte-identical to complete portable JSON")
|
|
require(digest(portable_bytes) == capsule["sha256"] == integrity["portable_document_sha256"],
|
|
"freeze and fixture digest agree with captured bytes")
|
|
model = portable["model"]
|
|
require(model["id"] == frozen["model_id"], "freeze model identity")
|
|
definitions = model["definitions"]
|
|
elements = model["elements"]
|
|
parameters = []
|
|
for record in definitions.values():
|
|
calculation = record["body"].get("Calculation")
|
|
if calculation:
|
|
scoped = {p["id"] for p in calculation["parameters"]}
|
|
parameters.extend(scoped)
|
|
for node in walk(calculation["body"]):
|
|
if isinstance(node, dict) and "Parameter" in node:
|
|
require(node["Parameter"] in scoped, "parameter reference remains in declaring calculation")
|
|
declared_ids = [model["id"], *definitions, *elements, *parameters]
|
|
source_ids = re.findall(r'\bid "([0-9a-f-]+)"', source)
|
|
require(len(declared_ids) == len(set(declared_ids)) == 17, "17 distinct typed identities")
|
|
require(set(source_ids) == set(declared_ids) and len(source_ids) == 17,
|
|
"every typed identity has exactly one explicit source id")
|
|
for identity in declared_ids:
|
|
require(str(uuid.UUID(identity)) == identity, f"canonical UUID: {identity}")
|
|
for key, record in {**definitions, **elements}.items():
|
|
require(key == record["id"], f"key/record identity agrees: {record['alias']}")
|
|
|
|
properties, cases, shared_checks = {}, {}, {}
|
|
for identity, record in elements.items():
|
|
layer = record["body"]["Oa"]
|
|
shared = layer.get("Shared", {}) if isinstance(layer, dict) else {}
|
|
for variant, output in (("EngineeringProperty", properties),
|
|
("AnalysisCase", cases), ("AnalysisCheck", shared_checks)):
|
|
if variant in shared:
|
|
output[identity] = shared[variant]
|
|
require(record["parent"] is None, f"root analysis element: {record['alias']}")
|
|
require(len(properties) == integrity["base_bindings"] == 4, "four explicit property bases")
|
|
require(sum(len(c["overrides"]) for c in cases.values()) == integrity["override_bindings"] == 2,
|
|
"two explicit case override entries")
|
|
require(len(shared_checks) == integrity["shared_checks"] == 1, "one shared check")
|
|
require(len(definitions) == integrity["local_definitions"] == 4, "four local definitions")
|
|
require(len(elements) == integrity["project_elements"] == 10, "ten project elements")
|
|
require(len(parameters) == integrity["scoped_parameters"] == 2, "two scoped parameters")
|
|
for node in walk(model):
|
|
if not isinstance(node, dict):
|
|
continue
|
|
if set(node) == {"Local"}:
|
|
require(node["Local"] in definitions, "local definition reference resolves")
|
|
if set(node) == {"Property"}:
|
|
require(node["Property"] in properties, "property expression reference resolves")
|
|
if set(node) == {"Element"}:
|
|
require(node["Element"] in elements, "element subject resolves")
|
|
if set(node) == {"Call"}:
|
|
call = node["Call"]
|
|
definition = definitions[call["definition"]["Local"]]["body"]["Calculation"]
|
|
require(set(call["arguments"]) == {p["id"] for p in definition["parameters"]},
|
|
"call arguments exactly match parameter identities")
|
|
|
|
case_id = frozen["context"]["Case"]
|
|
selected_case = cases[case_id]
|
|
require(selected_case["base"] == "ModelBaseline", "explicit model-baseline selector")
|
|
expected_bindings = []
|
|
for identity, prop in sorted(properties.items()):
|
|
overridden = identity in selected_case["overrides"]
|
|
expected_bindings.append({
|
|
"property": identity,
|
|
"binding": selected_case["overrides"][identity] if overridden else prop["base"],
|
|
"origin": {"CaseOverride": case_id} if overridden else "ModelBaseline",
|
|
})
|
|
require(frozen["effective_bindings"] == expected_bindings,
|
|
"all frozen binding ASTs and base/override origins match captured context")
|
|
require(frozen["check_predicates"] == [
|
|
{"check": identity, "predicate": check["predicate"]}
|
|
for identity, check in sorted(shared_checks.items())
|
|
], "all frozen shared check ASTs match captured model")
|
|
require(frozen["definition_capture"] == {
|
|
"document_sha256": digest(portable_bytes), "imports": [],
|
|
"local_definitions": sorted(definitions),
|
|
}, "frozen definition inventory and exact document hash agree")
|
|
require(portable["packages"] == model["imports"] == model["definition_mounts"] == {},
|
|
"local-only fixture makes no imported freeze claim")
|
|
for name in ("evaluate-baseline.json", "evaluate-degraded.json", "evaluate-unmeasured.json"):
|
|
request = read_json(ANALYSIS / name)
|
|
for key, pool in (("properties", properties), ("checks", shared_checks)):
|
|
ids = request["targets"][key]
|
|
require(len(ids) == len(set(ids)) and set(ids) <= set(pool), f"valid target identities: {name}/{key}")
|
|
|
|
literal_summary = []
|
|
expected_literals = {
|
|
"ten_to_300": (10 ** 300, 1),
|
|
"one_over_two_to_4095": (1, 2 ** 4095),
|
|
"negative_4096_bit_bound": (-(2 ** 4096 - 1), 1),
|
|
}
|
|
for packet in read_json(ANALYSIS / "r7-literal-boundaries.json"):
|
|
number = packet["expression"]["Number"]
|
|
n, d = int(number["numerator"]), int(number["denominator"])
|
|
require((n, d) == expected_literals[packet["name"]],
|
|
f"independently constructed boundary value: {packet['name']}")
|
|
require(str(n) == number["numerator"] and str(d) == number["denominator"],
|
|
f"canonical exact wire components: {packet['name']}")
|
|
require(d > 0 and math.gcd(n, d) == 1, f"normalized rational: {packet['name']}")
|
|
require(abs(n).bit_length() <= 4096 and d.bit_length() <= 4096,
|
|
f"actual 4096-bit boundary: {packet['name']}")
|
|
require(max(len(str(abs(n))), len(str(d))) <= 1234,
|
|
f"1234-digit component boundary: {packet['name']}")
|
|
expected_source = str(n) if n >= 0 and d == 1 else f"ratio({n}, {d})"
|
|
require(packet["canonical_source"] == expected_source,
|
|
f"canonical literal spelling agrees with exact Number node: {packet['name']}")
|
|
literal_summary.append({"name": packet["name"], "numerator_bits": abs(n).bit_length(),
|
|
"denominator_bits": d.bit_length(),
|
|
"numerator_digits": len(str(abs(n))), "denominator_digits": len(str(d))})
|
|
|
|
evidence = read_json(LIBRARY / "EVIDENCE.json")
|
|
require(len(evidence["files"]) == evidence["fixture_count"] == 81, "81 final library fixture hash entries")
|
|
require(len({p["path"] for p in evidence["files"]}) == 81, "no duplicated library evidence paths")
|
|
for entry in evidence["files"]:
|
|
require(entry["path"].startswith("generated-final/"), "only final library evidence")
|
|
data = (LIBRARY / entry["path"]).read_bytes()
|
|
require(digest(data) == entry["sha256"] and len(data) == entry["bytes"],
|
|
f"exact final library fixture: {entry['path']}")
|
|
updated = tree(LIBRARY / "generated-final/03-updated")
|
|
require(len(updated) == 11, "11 complete updated library files")
|
|
for folder in ("expected-full-updated", "05-fresh-process-reopened"):
|
|
require(updated == tree(LIBRARY / "generated-final" / folder), f"complete byte equality: {folder}")
|
|
require(evidence["assertions_passed"] == 120 and evidence["run_exit_code"] == 0
|
|
and evidence["fresh_process_reopen_exit_code"] == 0,
|
|
"author's recorded 120-assertion/fresh-process results (not rerun here)")
|
|
|
|
# Mathematical work-count witness, NOT an implementation or execution of fn.
|
|
# f0(x)=x; fn(x)=f(n-1)(2*x)+f(n-1)(2*x+1); evaluate f30(0).
|
|
# Each non-leaf body has 11 AST nodes; the root call has 2 more nodes.
|
|
# At depth k all 2**k argument values differ; result sums 0..2**30-1.
|
|
n = 30
|
|
work_witness = {
|
|
"definition_count": n + 1,
|
|
"stored_expression_nodes_including_root_call": 11 * n + 1 + 2,
|
|
"maximum_call_levels": n + 1,
|
|
"dynamic_definition_calls": 2 ** (n + 1) - 1,
|
|
"distinct_leaf_argument_values": 2 ** n,
|
|
"largest_leaf_argument_bits": (2 ** n - 1).bit_length(),
|
|
"exact_result_bits": ((2 ** n) * (2 ** n - 1) // 2).bit_length(),
|
|
"status": "closed-form count only; no billion-call evaluation executed",
|
|
}
|
|
|
|
results = {
|
|
"scope": "Read-only fixture transport/identity/manifest/hash audit; no proposed parser, full type checker, evaluator or Studio execution.",
|
|
"python": sys.version,
|
|
"audit_source_sha256": digest(Path(__file__).read_bytes()),
|
|
"exit_code": 0,
|
|
"checks_passed": len(checks),
|
|
"checks": checks,
|
|
"frozen_input_hashes": frozen_hashes,
|
|
"baseline_fixture_hashes": {name: digest(data) for name, data in sorted(analysis_files.items())},
|
|
"r7_literal_measurements": literal_summary,
|
|
"work_count_counterexample": work_witness,
|
|
"library_recorded_execution": {key: evidence[key] for key in
|
|
("compiler", "source_sha256", "executable_sha256", "assertions_passed",
|
|
"run_exit_code", "fresh_process_reopen_exit_code")},
|
|
}
|
|
(HERE / "audit-results.json").write_text(json.dumps(results, indent=2) + "\n", encoding="utf-8", newline="\n")
|
|
print(json.dumps({key: results[key] for key in ("checks_passed", "audit_source_sha256", "exit_code")}, indent=2))
|