From 01014cbe772ea5a59ccbc55266222433944c7368 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:59:51 -0500 Subject: [PATCH 1/4] test: retain frozen research routes across priority revisions (cherry picked from commit ba8a9e640e1983f3c29993fefa3f46e8ed03313a) --- tests/fixtures/README.md | 41 ++++++ tests/fixtures/research-routing-v7.json | 87 ++++++++++++ tests/test_research_current_assignment.py | 164 +++++++++++++++------- 3 files changed, 242 insertions(+), 50 deletions(-) create mode 100644 tests/fixtures/README.md create mode 100644 tests/fixtures/research-routing-v7.json diff --git a/tests/fixtures/README.md b/tests/fixtures/README.md new file mode 100644 index 0000000000..472a6a502f --- /dev/null +++ b/tests/fixtures/README.md @@ -0,0 +1,41 @@ +# Frozen research routing fixture + +`research-routing-v7.json` retains two exact task cards from priority revision 7: +`portable-replay` and `centre-path-sharing`. They exercise the generic-baseline +and historical-ceiling routes in `choose_current_research_task.py`. The fixture +records the source commit, path and SHA256. The card objects are unchanged. + +The source is commit `553d26d796fde9871ff2661a49ac7732e945410f`, file +`docs/research/agent-task-catalog.json`. The test places these cards in a small +catalogue with one track of weight 100. This carrier is test data, not a change +to research priorities. Current cards are checked separately from the live +catalogue. Every live card must preserve its other fields; each distinct direct +command also passes through both real CLIs. + +The CLI fixture copies the two real scripts. It creates inert reference files +for path validation and copies the current selected record for receipt fields. +It does not execute those references or verify a mathematical claim. Missing +references, sparse omissions, deleted files and staged replacements have separate +negative tests. No Git history, network request or change to the live catalogue +is needed to run the fixture. + +```sh +python3 -B -m unittest discover -s tests -p test_research_current_assignment.py -v +python3 -B -m unittest discover -s tests -p test_research_assignment.py -v +``` + +This fixture repairs the CI handoff in +[Discussion 5722](https://github.com/CrocSwap/integer-mult-bounds/discussions/5722). +The [investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/5758) +records the failure, checks and publication status. The original scripts, task +catalogue and selected frontier are unchanged. + +On base `de5ec2e7a6074068452f45b1a191b5c72832df4a`, the old suite has eight +failures and two errors. After the repair, all 12 current-assignment tests pass +under Python 3.14.7 and Python 3.12.14, including an isolated optimized run. +All 16 related assignment tests pass under Python 3.12.14. This is test coverage, +not a mathematical replay. See the investigation for hosted-plan status. + +Retain the original catalogue, routing and test authors, including Douglas +Colkitt, Ali Romman and Mihir Srivastava. New fixture and test repair: Ali Romman +with substantial OpenAI Codex assistance. No subagents. Apache-2.0. diff --git a/tests/fixtures/research-routing-v7.json b/tests/fixtures/research-routing-v7.json new file mode 100644 index 0000000000..f5d52ac21d --- /dev/null +++ b/tests/fixtures/research-routing-v7.json @@ -0,0 +1,87 @@ +{ + "source_commit": "553d26d796fde9871ff2661a49ac7732e945410f", + "source_path": "docs/research/agent-task-catalog.json", + "source_sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72", + "scope": "Two exact revision-7 cards. The test carrier is not a research allocation.", + "cards": [ + { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Removing copies without a replacement contract for the decoder's copied totals.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + { + "id": "portable-replay", + "question": "Can one reproducible environment or artifact-comparison failure be repaired?", + "starting_points": [ + "research/gzip-container-reproducibility/README.md", + "docs/ci-verification.md" + ], + "methods": [ + "Reproduce one portability failure and add a minimal cross-environment fix.", + "Audit one canonical-payload comparison for omitted proof-relevant fields." + ], + "acceptance_gate": "Preserve immutable source hashes and proof-relevant content; a different compressed byte stream alone is not a mathematical mismatch.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the gzip-container reproducibility examples and distinguish frozen source bytes from regenerated payloads.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Reproduce one specific mismatch or audit one canonical comparison for omitted proof-relevant fields.", + "bottleneck_link": "Portable exact checks prevent environment failures from blocking valid contributions.", + "allowed_variations": [ + "One interpreter/version mismatch or one payload field comparison." + ], + "scope_change_triggers": [ + "Removing immutable-source pins because generated compressed bytes differ." + ], + "overlap_terms": [ + "gzip container", + "reproducibility", + "canonical payload" + ] + } + ] +} diff --git a/tests/test_research_current_assignment.py b/tests/test_research_current_assignment.py index 860f6b9b9e..c524c0037f 100644 --- a/tests/test_research_current_assignment.py +++ b/tests/test_research_current_assignment.py @@ -1,9 +1,15 @@ -"""Current orientation must preserve frozen task-selection evidence.""" +"""Current orientation must preserve frozen task-selection evidence. + +Frozen fixtures and live-catalog coverage: Ali Romman with OpenAI Codex +assistance. Retain the original routing and test authors. Apache-2.0. +""" import copy +from contextlib import contextmanager import importlib.util import json from pathlib import Path import subprocess +import shutil import sys import tempfile import unittest @@ -15,16 +21,49 @@ LEGACY = current.LEGACY legacy = current.runpy.run_path(str(LEGACY)) CATALOG = json.loads((ROOT / legacy["CATALOG"]).read_text(encoding="utf-8")) +FROZEN = json.loads((ROOT / "tests/fixtures/research-routing-v7.json").read_text()) +FROZEN_CATALOG = { + "schema_version": 1, "priority_revision": 7, + "priority_log": "docs/research/routing-fixture.md", + "tracks": [{"id": "routing-fixtures", "weight": 100, "tasks": FROZEN["cards"]}], +} + + +@contextmanager +def frozen_cli_tree(): + """Run the real scripts with exact old cards and inert reference files.""" + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + required = {FROZEN_CATALOG["priority_log"], + "scripts/research_selected_baseline.py", "scripts/research_package.py", + "research/historical-complex-ceiling-replay/VERIFY.json", + "research/historical-complex-ceiling-replay/verify.py"} + for card in FROZEN["cards"]: + required.update(card["starting_points"]) + required.add(card["first_step"]["command"][-1]) + for name in required: + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("Inert reference for CLI validation only.\n") + for name in ("choose_research_task.py", "choose_current_research_task.py"): + shutil.copyfile(ROOT / "scripts" / name, root / "scripts" / name) + path = root / legacy["CATALOG"] + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(FROZEN_CATALOG)) + path = root / "certificates/selected-result.json" + path.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT / "certificates/selected-result.json", path) + yield root class CurrentResearchAssignmentTests(unittest.TestCase): - def test_every_frozen_card_and_other_fields_stay_exact(self): - before = copy.deepcopy(CATALOG) + def check_card_round_trips(self, catalog): + before = copy.deepcopy(catalog) resolved = 0 historical = 0 - for track in CATALOG["tracks"]: + for track in catalog["tracks"]: for task in track["tasks"]: - result = legacy["select"](CATALOG, "a1" * 16, task_id=task["id"]) + result = legacy["select"](catalog, "a1" * 16, task_id=task["id"]) original = copy.deepcopy(result) current.resolve_current_first_steps(result, ROOT) card = result["suggestions"][0] @@ -55,19 +94,25 @@ def test_every_frozen_card_and_other_fields_stay_exact(self): self.assertTrue(card.pop("first_step_resolution")) card["first_step"] = card.pop("catalog_first_step") self.assertEqual(result, original) - self.assertEqual(resolved, 16) - self.assertEqual(historical, 4) - self.assertEqual(CATALOG, before) + self.assertEqual(catalog, before) + return resolved, historical + + def test_frozen_routes_and_other_fields_stay_exact(self): + self.assertEqual(self.check_card_round_trips(FROZEN_CATALOG), (1, 1)) + + def test_every_live_card_and_other_fields_stay_exact(self): + self.assertTrue(CATALOG["tracks"]) + self.check_card_round_trips(CATALOG) def test_only_exact_generic_command_is_resolved(self): - result = copy.deepcopy(legacy["select"](CATALOG, "0" * 32, task_id="portable-replay")) + result = copy.deepcopy(legacy["select"](FROZEN_CATALOG, "0" * 32, task_id="portable-replay")) result["suggestions"][0]["first_step"]["command"].append("--historical-fixture") original = copy.deepcopy(result) self.assertEqual(current.resolve_current_first_steps(result, ROOT), []) self.assertEqual(result, original) def test_missing_current_helper_does_not_change_receipt(self): - result = legacy["select"](CATALOG, "0" * 32, task_id="portable-replay") + result = legacy["select"](FROZEN_CATALOG, "0" * 32, task_id="portable-replay") original = copy.deepcopy(result) with tempfile.TemporaryDirectory() as directory: with self.assertRaisesRegex(ValueError, "missing current first-step script"): @@ -82,7 +127,7 @@ def test_nonexact_scientific_commands_are_not_reinterpreted(self): ): with self.subTest(command=command): result = copy.deepcopy(legacy["select"]( - CATALOG, "0" * 32, task_id="centre-path-sharing")) + FROZEN_CATALOG, "0" * 32, task_id="centre-path-sharing")) result["suggestions"][0]["first_step"]["command"] = command original = copy.deepcopy(result) self.assertEqual(current.resolve_current_first_steps(result, ROOT), []) @@ -102,34 +147,52 @@ def test_missing_historical_reference_leaves_all_cards_unchanged(self): path = root / name path.parent.mkdir(parents=True, exist_ok=True) path.write_text("fixture\n") - result = legacy["select"](CATALOG, "0" * 32, task_id="portable-replay") + result = legacy["select"](FROZEN_CATALOG, "0" * 32, task_id="portable-replay") result["suggestions"] += legacy["select"]( - CATALOG, "0" * 32, task_id="centre-path-sharing")["suggestions"] + FROZEN_CATALOG, "0" * 32, task_id="centre-path-sharing")["suggestions"] original = copy.deepcopy(result) with self.assertRaises(ValueError) as raised: current.resolve_current_first_steps(result, root) self.assertIn(absent, str(raised.exception)) self.assertEqual(result, original) - def cli(self, script, args): - return subprocess.run([sys.executable, "-B", str(script), *args], cwd=ROOT, + def cli(self, script, args, root=ROOT): + return subprocess.run([sys.executable, "-B", str(root / "scripts" / Path(script).name), *args], cwd=root, capture_output=True, text=True, encoding="utf-8") def test_cli_preserves_legacy_output_and_emits_both_commands(self): - args = ["--seed", "0" * 32, "--task", "portable-replay"] - original = self.cli(LEGACY, args) - output = self.cli(ROOT / "scripts/choose_current_research_task.py", args) - self.assertEqual(original.returncode, 0) - self.assertEqual(output.returncode, 0) - old, new = json.loads(original.stdout), json.loads(output.stdout) - card = new["suggestions"][0] - self.assertEqual(card["first_step"]["command"], - ["python3", "-B", "scripts/research_selected_baseline.py"]) - self.assertEqual(card.pop("catalog_first_step"), old["suggestions"][0]["first_step"]) - self.assertTrue(card.pop("first_step_resolution")) - card["first_step"] = old["suggestions"][0]["first_step"] - self.assertEqual(new, old) - self.assertEqual(self.cli(LEGACY, args).stdout, original.stdout) + with frozen_cli_tree() as root: + args = ["--seed", "0" * 32, "--task", "portable-replay"] + original = self.cli(LEGACY, args, root) + output = self.cli(ROOT / "scripts/choose_current_research_task.py", args, root) + self.assertEqual(original.returncode, 0) + self.assertEqual(output.returncode, 0) + old, new = json.loads(original.stdout), json.loads(output.stdout) + card = new["suggestions"][0] + self.assertEqual(card["first_step"]["command"], + ["python3", "-B", "scripts/research_selected_baseline.py"]) + self.assertEqual(card.pop("catalog_first_step"), old["suggestions"][0]["first_step"]) + self.assertTrue(card.pop("first_step_resolution")) + card["first_step"] = old["suggestions"][0]["first_step"] + self.assertEqual(new, old) + self.assertEqual(self.cli(LEGACY, args, root).stdout, original.stdout) + + def test_live_cli_preserves_each_unmapped_command(self): + checked = {tuple(card["first_step"]["command"]) for card in FROZEN["cards"]} + for track in CATALOG["tracks"]: + for task in track["tasks"]: + command = tuple(task["first_step"]["command"]) + if command in checked: + continue + checked.add(command) + with self.subTest(task=task["id"]): + args = ["--seed", "0" * 32, "--task", task["id"]] + original = self.cli(LEGACY, args) + output = self.cli(ROOT / "scripts/choose_current_research_task.py", args) + self.assertEqual(original.returncode, 0, original.stderr) + self.assertEqual(output.returncode, 0, output.stderr) + self.assertEqual(json.loads(output.stdout), json.loads(original.stdout)) + self.assertEqual(self.cli(LEGACY, args).stdout, original.stdout) def test_help_and_error_preserve_child_status_and_output(self): for args, code in ((["--help"], 0), (["--unknown-option"], 2), (["--seed", "bad"], 2)): @@ -139,23 +202,24 @@ def test_help_and_error_preserve_child_status_and_output(self): self.assertEqual((output.stdout, output.stderr), (original.stdout, original.stderr)) def test_cli_distinguishes_current_orientation_from_historical_control(self): - args = ["--seed", "0" * 32, "--task", "complex-new-helper-inventory"] - original = self.cli(LEGACY, args) - output = self.cli(ROOT / "scripts/choose_current_research_task.py", args) - self.assertEqual(original.returncode, 0, original.stderr) - self.assertEqual(output.returncode, 0, output.stderr) - old, new = json.loads(original.stdout), json.loads(output.stdout) - card = new["suggestions"][0] - self.assertEqual(card["first_step"]["command"][2], "scripts/research_selected_baseline.py") - self.assertEqual(card["first_step"]["expected"], "PASS_RESEARCH_BASELINE_BINDINGS_ONLY") - follow_up, = card.pop("follow_up_steps") - self.assertEqual(follow_up["command"][-1], "research/historical-complex-ceiling-replay") - self.assertIn("historical", follow_up["scope"].lower()) - self.assertIn("cost law", follow_up["inspect"]) - self.assertTrue(card.pop("first_step_resolution")) - card["first_step"] = card.pop("catalog_first_step") - self.assertEqual(new, old) - self.assertEqual(self.cli(LEGACY, args).stdout, original.stdout) + with frozen_cli_tree() as root: + args = ["--seed", "0" * 32, "--task", "centre-path-sharing"] + original = self.cli(LEGACY, args, root) + output = self.cli(ROOT / "scripts/choose_current_research_task.py", args, root) + self.assertEqual(original.returncode, 0, original.stderr) + self.assertEqual(output.returncode, 0, output.stderr) + old, new = json.loads(original.stdout), json.loads(output.stdout) + card = new["suggestions"][0] + self.assertEqual(card["first_step"]["command"][2], "scripts/research_selected_baseline.py") + self.assertEqual(card["first_step"]["expected"], "PASS_RESEARCH_BASELINE_BINDINGS_ONLY") + follow_up, = card.pop("follow_up_steps") + self.assertEqual(follow_up["command"][-1], "research/historical-complex-ceiling-replay") + self.assertIn("historical", follow_up["scope"].lower()) + self.assertIn("cost law", follow_up["inspect"]) + self.assertTrue(card.pop("first_step_resolution")) + card["first_step"] = card.pop("catalog_first_step") + self.assertEqual(new, old) + self.assertEqual(self.cli(LEGACY, args, root).stdout, original.stdout) def test_sparse_historical_references_require_unchanged_head_entries(self): with tempfile.TemporaryDirectory() as directory: @@ -178,12 +242,12 @@ def git(*args): git("update-index", "--skip-worktree", *omitted) for name in omitted: (root / name).unlink() - result = legacy["select"](CATALOG, "0" * 32, task_id="coverage-law-change") + result = legacy["select"](FROZEN_CATALOG, "0" * 32, task_id="centre-path-sharing") self.assertEqual(current.resolve_current_first_steps(result, root), sorted(omitted)) # Ordinary deletion must not acquire the deliberate-sparse exemption. changed = omitted[-1] git("update-index", "--no-skip-worktree", changed) - result = legacy["select"](CATALOG, "0" * 32, task_id="coverage-law-change") + result = legacy["select"](FROZEN_CATALOG, "0" * 32, task_id="centre-path-sharing") original = copy.deepcopy(result) with self.assertRaises(ValueError): current.resolve_current_first_steps(result, root) @@ -208,9 +272,9 @@ def git(*args): git("-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid", "-c", "core.hooksPath=/dev/null", "commit", "-qm", "helper") git("update-index", "--skip-worktree", name); path.unlink() - result = legacy["select"](CATALOG, "0" * 32, task_id="portable-replay") + result = legacy["select"](FROZEN_CATALOG, "0" * 32, task_id="portable-replay") self.assertEqual(current.resolve_current_first_steps(result, root), [name]) git("update-index", "--no-skip-worktree", name) - result = legacy["select"](CATALOG, "0" * 32, task_id="portable-replay") + result = legacy["select"](FROZEN_CATALOG, "0" * 32, task_id="portable-replay") with self.assertRaisesRegex(ValueError, "missing current first-step script"): current.resolve_current_first_steps(result, root) From 2ebc3a071c62fc839aaed1291220d78a317395d4 Mon Sep 17 00:00:00 2001 From: d3lerium Date: Tue, 27 Oct 2026 20:13:13 +1100 Subject: [PATCH 2/4] Freeze native qualifier predecessor inputs with source provenance --- .../GETTER-SHAPES.json | 4 + .../compact_finite.py | 78 +++++++++ .../compact_parent.py | 106 +++++++++++ .../entry_finite.py | 128 ++++++++++++++ .../entry_parent.py | 99 +++++++++++ .../fraction-native-qualification/frozen.py | 67 +++++++ .../inputs/PR5848.tar | Bin 0 -> 614400 bytes .../parent_finite.py | 164 ++++++++++++++++++ .../slot_binding.py | 53 ++++++ .../slot_finite.py | 75 ++++++++ .../slot_parent.py | 85 +++++++++ .../table_parent.py | 123 +++++++++++++ 12 files changed, 982 insertions(+) create mode 100644 research/fraction-native-qualification/GETTER-SHAPES.json create mode 100644 research/fraction-native-qualification/compact_finite.py create mode 100644 research/fraction-native-qualification/compact_parent.py create mode 100644 research/fraction-native-qualification/entry_finite.py create mode 100644 research/fraction-native-qualification/entry_parent.py create mode 100644 research/fraction-native-qualification/frozen.py create mode 100644 research/fraction-native-qualification/inputs/PR5848.tar create mode 100644 research/fraction-native-qualification/parent_finite.py create mode 100644 research/fraction-native-qualification/slot_binding.py create mode 100644 research/fraction-native-qualification/slot_finite.py create mode 100644 research/fraction-native-qualification/slot_parent.py create mode 100644 research/fraction-native-qualification/table_parent.py diff --git a/research/fraction-native-qualification/GETTER-SHAPES.json b/research/fraction-native-qualification/GETTER-SHAPES.json new file mode 100644 index 0000000000..d3dadac227 --- /dev/null +++ b/research/fraction-native-qualification/GETTER-SHAPES.json @@ -0,0 +1,4 @@ +{ + "numerator": "2223091528d16d7797026549874741a186c586604b625862f0c09b4baadafdcf", + "denominator": "dba448f5b021e71de33e6a5b388bac53022b886e7d8cb0ca59577ff038467efd" +} diff --git a/research/fraction-native-qualification/compact_finite.py b/research/fraction-native-qualification/compact_finite.py new file mode 100644 index 0000000000..b6cc3d9ddb --- /dev/null +++ b/research/fraction-native-qualification/compact_finite.py @@ -0,0 +1,78 @@ +"""All inherited coverage plus token, q-context, collision and FIFO controls.""" +import importlib.util +import json +import sys +from fractions import Fraction as F +import entry_finite +import entry_parent as entry +from entry_finite import fixtures,types_of +from frozen import baseline,require +import fraction_table as table + + +def main(): + inherited=entry_finite.main();controls=[] + weights=[(F(1),F(2)),(F(3),F(5)),(F(2,2),F(4,2))] + tokens=table.weight_tokens(weights) + require(tokens==[0,1,0],'canonical equal pairs share a token') + controls.append('canonical-full-pair-tokens') + modulus=sys.hash_info.modulus + collision=[(F(0),F(1)),(F(modulus),F(1))] + keys=lambda w:(w[0].numerator,w[0].denominator,w[1].numerator,w[1].denominator) + require(hash(keys(collision[0]))==hash(keys(collision[1])) and keys(collision[0])!=keys(collision[1]),'real canonical hash collision') + require(table.weight_tokens(collision)==[0,1],'full equality after hash collision') + controls.append('weight-token-hash-collision') + require(table.weight_tokens(weights,1) is None,'context overflow rejects compression') + require(table.weight_tokens([],0)==[],'empty zero-capacity context') + controls.append('bounded-context-overflow') + # Same exact equality relation and global FIFO sequence at each capacity. + word=dict(public=1,owned_fields=0,program=[]) + for capacity in (1,2,16): + old=entry.Contributions(capacity);old.certify(word,weights,set()) + new=table.CompactContributions(capacity,weights,tokens) + for q in (F(1),F(-1),F(2),F(1,2),F(2,4),F(1)): + step=new.event(q) + for index,i in enumerate((0,1,2,0,2,1,0,1,2)): + a,b=F(index%2),F((index%3)-1) + require(step(a,b,i)==old.step(a,q,b,*weights[i]),'same exact contribution') + require(new.statistics()==old.statistics(),'same complete FIFO/counters') + controls.append('event-q-canonical-equality-and-FIFO-counters') + with baseline() as package: + sys.path.insert(0,str(package)) + spec=importlib.util.spec_from_file_location('compact_bundle',package/'source.py') + source=importlib.util.module_from_spec(spec);spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('compact_finite_source',p/'verify.py') + v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,_,ref): + original=ref.error_trace;fast=table.derive(ref);parent=entry.derive(ref) + for index,c in enumerate(fixtures()): + if index in (0,23,71,142,200,239): + a=parent(*c);b=fast(*c) + require(a==b and types_of(a)==types_of(b),'complete parent/compact trace types') + require(fast.compacted_selected() is True,'compact route actually executed') + require(parent.statistics()==fast.statistics(),'full finite actual counter sequence') + controls.append('six-complete-trace-counter-and-type-comparisons') + fixture=(dict(public=4,owned_fields=0,program=[['INIT',0,0],['INIT',1,0],['ADD',2,0,1,0],['ADD',3,1,1,0]]),[(F(1),F(2)),(F(3),F(5)),(F(7),F(11)),(F(13),F(17))],{'INIT'}) + require(fast(*fixture)==original(*fixture),'source weights vary by i, not event') + controls.append('source-site-weight-ownership') + factory=table.weight_tokens + table.weight_tokens=lambda w:[0]*len(w) + try:require(table.derive(ref)(*fixture)!=original(*fixture),'wrong token merges rejected') + finally:table.weight_tokens=factory + controls.append('wrong-token-alias-detected') + table.weight_tokens=lambda w:factory(w,1) + try: + fallback=table.derive(ref) + require(fallback(*fixture)==original(*fixture) and fallback.compacted_selected() is False,'whole-call overflow fallback') + finally:table.weight_tokens=factory + controls.append('overflow-fallback-preserves-original') + # Reusing token numbers in a later trace cannot reuse an answer. + a=fast(*fixture);counts=fast.statistics();changed=(fixture[0],list(reversed(fixture[1])),fixture[2]) + require(fast(*changed)==original(*changed),'new trace tokens independent') + require(fast(*fixture)==a and fast.statistics()==counts,'fresh table on each call') + controls.append('fresh-token-and-cache-lifetimes') + result=dict(status='PASS_COMPACT_KEY_FINITE_ONLY',inherited=inherited,new_controls=controls,new_control_count=len(controls),all_coverage_preserved=True) + print(json.dumps(result,sort_keys=True));return result + +if __name__=='__main__':main() diff --git a/research/fraction-native-qualification/compact_parent.py b/research/fraction-native-qualification/compact_parent.py new file mode 100644 index 0000000000..b3dc1be5c0 --- /dev/null +++ b/research/fraction-native-qualification/compact_parent.py @@ -0,0 +1,106 @@ +"""Compact exact table keys; original Fraction arithmetic on every miss.""" +from contextlib import contextmanager +from hashlib import sha256 +import inspect +from pathlib import Path +import entry_parent as entry + +F=entry.F +CAPACITY=entry.CAPACITY +CONTEXT_CAPACITY=16384 +Contributions=entry.Contributions +NORMAL_CONTRIBUTIONS=Contributions +certified_domain=entry.certified_domain +transformed=entry.transformed + + +def weight_tokens(weights,limit=CONTEXT_CAPACITY): + entry.parent.need(type(limit) is int and 0<=limit<=CONTEXT_CAPACITY,'bounded context token capacity') + mapping={};tokens=[] + for row in weights: + a,c=row[0],row[1] + key=(a.numerator,a.denominator,c.numerator,c.denominator) + token=mapping.get(key) + if token is None: + if len(mapping)>=limit:return None + token=len(mapping);mapping[key]=token + tokens.append(token) + return tokens + + +class CompactContributions(NORMAL_CONTRIBUTIONS): + def __init__(self,capacity,weights,tokens): + super().__init__(capacity) + self.weights=weights;self.tokens=tokens + + def event(self,q): + qn,qd=q.numerator,q.denominator + table=self.table;weights=self.weights;tokens=self.tokens;capacity=self.capacity + compute=self.compute + def step(old,v,i): + self.calls+=1 + key=(old.numerator,old.denominator,qn,qd,v.numerator,v.denominator,tokens[i]) + result=table.get(key) + if result is not None: + self.hits+=1 + return result + self.misses+=1 + result=compute(old,q,v,weights[i][0],weights[i][1]) + if len(table)>=capacity: + table.popitem(last=False);self.evictions+=1 + table[key]=result + return result + return step + + +def compact_text(raw): + text=transformed(raw) + before='def error_trace(word, weights, rounded):\n' + entry.parent.need(text.count(before)==1,'one compact function signature') + text=text.replace(before,'def error_trace(word, weights, rounded, tokens):\n') + before=' contributions = _contribution_factory()\n contributions.certify(word,weights,rounded)\n' + entry.parent.need(text.count(before)==1,'one compact factory seam') + text=text.replace(before,' contributions = _compact_factory(weights,tokens)\n') + before=" elif op in ('ADD', 'COPY'):\n q = F(event[-2])\n for i, v in rows[event[2]].items():\n" + entry.parent.need(text.count(before)==1,'one source ADD/COPY event seam') + text=text.replace(before," elif op in ('ADD', 'COPY'):\n q = F(event[-2])\n step_contribution = contributions.event(q)\n for i, v in rows[event[2]].items():\n") + before=''' value, increment_a, increment_c, change = contributions.step( + old, q, v, weights[i][0], weights[i][1]) +''' + entry.parent.need(text.count(before)==1,'one compact call seam') + return text.replace(before,' value, increment_a, increment_c, change = step_contribution(old,v,i)\n') + + +def derive(reference,capacity=CAPACITY): + parent=entry.parent + parent.need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + parent.need(reference.F is F,'exact standard Fraction type') + parent.need(sha256(Path(reference.__file__).read_bytes()).hexdigest()==parent.MODULE_SHA256,'exact Fraction module bytes') + original=reference.error_trace;raw=inspect.getsource(original) + safe=transformed(raw);compact=compact_text(raw) + namespace=dict(reference.__dict__) + exec(compile(raw,'','exec'),namespace) + parent.need(parent.code_shape(original.__code__)==parent.code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + parent.need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + last=[None,None,None] + factory=Contributions + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:factory(capacity),_contribution_report=report, + _compact_factory=lambda weights,tokens:CompactContributions(capacity,weights,tokens)) + exec(compile(safe,'','exec'),namespace);generic=namespace['error_trace'] + exec(compile(compact,'','exec'),namespace);specialized=namespace['error_trace'] + def call(word,weights,rounded): + tokens=weight_tokens(weights) if capacity and factory is NORMAL_CONTRIBUTIONS and certified_domain(word,weights,rounded) else None + last[1]=tokens is not None;last[2]=None if tokens is None else (max(tokens)+1 if tokens else 0) + return specialized(word,weights,rounded,tokens) if tokens is not None else generic(word,weights,rounded) + call.statistics=lambda:None if last[0] is None else dict(last[0]) + call.compacted_selected=lambda:last[1] + call.token_count=lambda:last[2] + return call + + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace;derived=derive(reference,capacity);reference.error_trace=derived + try:yield derived + finally:reference.error_trace=original diff --git a/research/fraction-native-qualification/entry_finite.py b/research/fraction-native-qualification/entry_finite.py new file mode 100644 index 0000000000..cafaf408fd --- /dev/null +++ b/research/fraction-native-qualification/entry_finite.py @@ -0,0 +1,128 @@ +"""All unchanged predecessor finite coverage plus entry/fallback controls.""" +from copy import deepcopy +import importlib.util +import json +import sys +from fractions import Fraction as F +import fraction_table as table +import parent_finite +from parent_finite import types_of,fixtures +from frozen import baseline,require + + +def main(): + inherited=parent_finite.main() + controls=[] + cases=list(fixtures()) + base=cases[0] + require(table.certified_domain(*base),'ordinary fixture certified') + require(all(table.certified_domain(*c) for c in cases),'all inherited fixtures certified') + controls.append('all-241-fixtures-take-certified-domain') + class DictSubclass(dict): + def __getitem__(self,key): + log.append(('word-get',key));return super().__getitem__(key) + class ListSubclass(list): + def __iter__(self): + log.append('list-iter');return super().__iter__() + def __getitem__(self,key): + log.append(('list-get',key));return super().__getitem__(key) + class TupleSubclass(tuple): + def __iter__(self): + log.append('tuple-iter');return super().__iter__() + def __getitem__(self,key): + log.append(('tuple-get',key));return super().__getitem__(key) + class SetSubclass(set): + def __contains__(self,key): + log.append(('set-contains',key));return super().__contains__(key) + class FractionSubclass(F): + pass + log=[] + bad_domains=[] + def changed_word(key,value): + w=deepcopy(base[0]);w[key]=value;return w,deepcopy(base[1]),set(base[2]) + bad_domains.append(('dict-subclass',(DictSubclass(base[0]),deepcopy(base[1]),set(base[2])))) + bad_domains.append(('program-subclass',changed_word('program',ListSubclass(base[0]['program'])))) + bad_domains.append(('event-subclass',changed_word('program',[TupleSubclass(e) for e in base[0]['program']])) ) + bad_domains.append(('weights-subclass',(deepcopy(base[0]),ListSubclass(base[1]),set(base[2])))) + bad_domains.append(('row-subclass',(deepcopy(base[0]),[TupleSubclass(r) for r in base[1]],set(base[2])))) + bad_domains.append(('rounded-subclass',(deepcopy(base[0]),deepcopy(base[1]),SetSubclass(base[2])))) + bad_domains.append(('Fraction-subclass',(deepcopy(base[0]),[(FractionSubclass(a),c) for a,c in base[1]],set(base[2])))) + bad_domains.append(('integer-weights',(deepcopy(base[0]),[(1,2)]*len(base[1]),set(base[2])))) + bad_domains.append(('boolean-public',changed_word('public',True))) + for label,c in bad_domains: + log.clear();require(not table.certified_domain(*c),'fallback domain '+label) + require(not log,'gate invokes no custom methods '+label) + controls.append('subtypes-and-foreign-types-fall-back-without-custom-methods') + class HostileMeta(type): + def __eq__(cls,other): + log.append('metaclass-equality');return False + class Foreign(metaclass=HostileMeta):pass + for label,c in [('metaclass-container',(deepcopy(base[0]),Foreign(),set(base[2]))),('metaclass-scalar',changed_word('program',[['ADD',0,1,Foreign(),0]]))]: + log.clear();require(not table.certified_domain(*c),'foreign metaclass falls back') + require(not log,'no foreign metaclass equality methods') + controls.append(label) + with baseline() as package: + sys.path.insert(0,str(package)) + source_spec=importlib.util.spec_from_file_location('type_gate_additional_bundle',package/'source.py') + source=importlib.util.module_from_spec(source_spec);source_spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('type_gate_finite_source',p/'verify.py') + v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,_,ref): + old=ref.error_trace;fast=table.derive(ref) + for label,c in bad_domains: + outcomes=[] + for fn in (old,fast): + log.clear() + try: + value=fn(*c);outcome=('value',value,types_of(value)) + except (IndexError,ValueError,TypeError,KeyError) as e: + outcome=('error',type(e).__name__,str(e)) + outcomes.append((outcome,list(log))) + require(outcomes[0]==outcomes[1],'original outcome and custom-method order '+label) + controls.append('original-fallback-'+label) + # Audit the invariant on a representative complete mixed-operation + # trace and dyadic cancellation/large-rational fixtures. This extra + # checking exists only in this finite control, never in timing runs. + normal=table.Contributions + checked_calls=[0] + class Checked(normal): + def _certified_step(self,*operands): + require(all(type(x) is F for x in operands),'certified operands exact Fraction') + checked_calls[0]+=1 + out=super()._certified_step(*operands) + require(all(type(x) is F for x in out),'certified results exact Fraction') + return out + table.Contributions=Checked + try: + checked=table.derive(ref) + for c in [base,cases[71],cases[142],cases[239]]: + require(checked(*c)==old(*c),'inductive type instrumentation preserves values') + finally:table.Contributions=normal + require(checked_calls[0]>0,'certified path actually executed') + controls.append('exact-internal-type-preservation-at-certified-updates') + for label,c in [ + ('missing-weight',(dict(public=2,owned_fields=0,program=[['ADD',0,1,1,0]]),[],{'ADD'})), + ('bad-role',(dict(public=2,owned_fields=0,program=[['ADD',99,0,1,0]]),[(F(1),F(1))],{'ADD'})), + ('bad-scalar',(dict(public=2,owned_fields=0,program=[['ADD',0,1,'bad',0]]),[(F(1),F(1))],{'ADD'})), + ('short-event',(dict(public=2,owned_fields=0,program=[['ADD']]),[(F(1),F(1))],{'ADD'}))]: + outcomes=[] + for fn in (old,fast): + try:fn(*c) + except (IndexError,ValueError,TypeError) as e:outcomes.append((type(e).__name__,str(e))) + else:outcomes.append(('no-error',None)) + require(outcomes[0]==outcomes[1],'same malformed-input outcome '+label) + controls.append('malformed-outcome-'+label) + # Invalidation if a table is explicitly certified a second time. + c=table.Contributions(2);c.certify(*base) + require(c.certified,'entry selected certified path') + foreign=(deepcopy(base[0]),[(1,2)]*len(base[1]),set(base[2])) + c.certify(*foreign);require(not c.certified,'recertification removes fast path') + require(c.step(F(0),F(1),F(1),1,2)==c.compute(F(0),F(1),F(1),1,2) and c.bypasses==1,'recertified fallback preserves non-Fraction operands') + controls.append('recertification-invalidates-certified-method') + c=table.Contributions(0);c.certify(*base) + require(not c.certified,'disabled table stays checked');controls.append('disabled-capacity-not-certified') + result=dict(status='PASS_TYPE_GATE_FINITE_FEASIBILITY',inherited=inherited,new_controls=controls,new_control_count=len(controls),all_coverage_preserved=True) + print(json.dumps(result,sort_keys=True));return result + +if __name__=='__main__':main() diff --git a/research/fraction-native-qualification/entry_parent.py b/research/fraction-native-qualification/entry_parent.py new file mode 100644 index 0000000000..2a631bdc4c --- /dev/null +++ b/research/fraction-native-qualification/entry_parent.py @@ -0,0 +1,99 @@ +"""Source-bound entry type gate for the exact predecessor contribution table. + +Ali Romman: original Fraction arithmetic. Chris R / Clear1nsight with +substantial OpenAI Codex assistance: table and entry-domain proof. Apache-2.0. +The independent integer engine, arithmetic and complete output stay unchanged. +""" +from contextlib import contextmanager +from hashlib import sha256 +import inspect +from pathlib import Path +import table_parent as parent + +F=parent.F +CAPACITY=parent.CAPACITY + + +def certified_domain(word,weights,rounded): + # Test exact container types before inspecting members. No user-defined + # iteration, conversion, comparison, indexing or numeric methods run here. + if type(word) is not dict or any(type(k) is not str for k in word): + return False + if type(word.get('public')) is not int or type(word.get('owned_fields')) is not int: + return False + program=word.get('program') + if (type(program) is not list and type(program) is not tuple) or (type(weights) is not list and type(weights) is not tuple): + return False + if (type(rounded) is not set and type(rounded) is not frozenset) or any(type(op) is not str for op in rounded): + return False + for event in program: + if (type(event) is not list and type(event) is not tuple) or len(event)<2: + return False + if type(event[0]) is not str: + return False + if any(type(x) is not str and type(x) is not int and type(x) is not bool and type(x) is not F for x in event): + return False + for row in weights: + if (type(row) is not list and type(row) is not tuple) or len(row)<2: + return False + if type(row[0]) is not F or type(row[1]) is not F: + return False + return True + + +class Contributions(parent.Contributions): + def certify(self,word,weights,rounded): + self.certified=bool(self.capacity and certified_domain(word,weights,rounded)) + self.step=self._certified_step if self.certified else super().step + + def _certified_step(self,old,q,v,a,c): + self.calls+=1 + key=(old.numerator,old.denominator,q.numerator,q.denominator, + v.numerator,v.denominator,a.numerator,a.denominator,c.numerator,c.denominator) + result=self.table.get(key) + if result is not None: + self.hits+=1 + return result + self.misses+=1 + result=self.compute(old,q,v,a,c) + if len(self.table)>=self.capacity: + self.table.popitem(last=False) + self.evictions+=1 + self.table[key]=result + return result + + +def transformed(raw): + text=parent.transformed(raw) + seam=' contributions = _contribution_factory()\n' + parent.need(text.count(seam)==1,'one entry type certification seam') + return text.replace(seam,seam+' contributions.certify(word,weights,rounded)\n') + + +def derive(reference,capacity=CAPACITY): + parent.need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + parent.need(reference.F is F,'exact standard Fraction type') + parent.need(sha256(Path(reference.__file__).read_bytes()).hexdigest()==parent.MODULE_SHA256,'exact Fraction module bytes') + original=reference.error_trace + raw=inspect.getsource(original) + text=transformed(raw) + namespace=dict(reference.__dict__) + exec(compile(raw,'','exec'),namespace) + parent.need(parent.code_shape(original.__code__)==parent.code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + parent.need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + last=[None] + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:Contributions(capacity),_contribution_report=report) + exec(compile(text,'','exec'),namespace) + result=namespace['error_trace'] + result.statistics=lambda:None if last[0] is None else dict(last[0]) + return result + + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace + derived=derive(reference,capacity) + reference.error_trace=derived + try:yield derived + finally:reference.error_trace=original diff --git a/research/fraction-native-qualification/frozen.py b/research/fraction-native-qualification/frozen.py new file mode 100644 index 0000000000..eb26be4a0f --- /dev/null +++ b/research/fraction-native-qualification/frozen.py @@ -0,0 +1,67 @@ +"""Authenticate the unchanged complete PR5848 export before importing it.""" +from contextlib import contextmanager +from hashlib import sha256 +import json +from pathlib import Path +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent +BUNDLE_SHA256 = 'f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6' +SOURCE_HEAD = '66fb6c6b8683b37967e9d7f313b3df99a49d2406' + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def payload(archive=None): + archive = HERE / 'inputs/PR5848.tar' if archive is None else archive + require(sha256(archive.read_bytes()).hexdigest() == BUNDLE_SHA256, 'Exact PR5848 bundle') + with tarfile.open(archive, 'r:') as stream: + members = stream.getmembers() + require(len(members) == 98 and len({m.name for m in members}) == 98, 'Complete unique baseline bundle') + require(all(m.isfile() and 0 <= m.size <= 8 * 1024**2 for m in members), 'Regular bounded baseline members') + receipt = json.loads(stream.extractfile('.research-export.json').read()) + require(receipt['commit'] == SOURCE_HEAD, 'Exact baseline export head') + rows = {r['path']: r for r in receipt['files']} + require(len(rows) == len(receipt['files']) == 97, 'Complete baseline file census') + require({m.name for m in members} == set(rows) | {'.research-export.json'}, 'Exact baseline member set') + contents = {} + for member in members: + path = Path(member.name) + require(not path.is_absolute() and '..' not in path.parts and path.parts, 'Safe baseline path') + raw = stream.extractfile(member).read() + if member.name in rows: + row = rows[member.name] + require(len(raw) == row['size'] and sha256(raw).hexdigest() == row['sha256'], 'Exact baseline file bytes') + require(row['mode'] in (0o644, 0o755), 'Regular baseline file mode') + contents[member.name] = raw + return contents + + +@contextmanager +def baseline(): + contents = payload() + with tempfile.TemporaryDirectory(prefix='precision-linux-source-') as temporary: + root = Path(temporary) + try: + for name, raw in contents.items(): + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + path.chmod(0o444) + for path in root.rglob('*'): + if path.is_dir(): + path.chmod(0o555) + before = {str(p.relative_to(root)): [sha256(p.read_bytes()).hexdigest(), p.stat().st_mode & 0o777] + for p in root.rglob('*') if p.is_file()} + yield root / 'research/p104-single-pass-qualification' + after = {str(p.relative_to(root)): [sha256(p.read_bytes()).hexdigest(), p.stat().st_mode & 0o777] + for p in root.rglob('*') if p.is_file() and not p.is_symlink()} + require(after == before and not any(p.is_symlink() for p in root.rglob('*')), 'Baseline export unchanged') + finally: + for path in [root, *root.rglob('*')]: + if path.is_dir(): + path.chmod(0o755) diff --git a/research/fraction-native-qualification/inputs/PR5848.tar b/research/fraction-native-qualification/inputs/PR5848.tar new file mode 100644 index 0000000000000000000000000000000000000000..307d09d2a968e1bbec8025d9fbd0a884df790d12 GIT binary patch literal 614400 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

8gCzvc2CkmItFjsOTxeQNNu>7mNY{iI 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�n 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⋘82 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

>wU;rIg7`&?ky6nbDac~j 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 kf$a=zXJ9)6+Zou-z;*_b%7 literal 0 HcmV?d00001 diff --git a/research/fraction-native-qualification/parent_finite.py b/research/fraction-native-qualification/parent_finite.py new file mode 100644 index 0000000000..e00dd29385 --- /dev/null +++ b/research/fraction-native-qualification/parent_finite.py @@ -0,0 +1,164 @@ +"""Finite gate before construction, using the actual frozen Fraction source.""" +from copy import deepcopy +from fractions import Fraction as F +import importlib.util +import inspect +import json +from pathlib import Path +import random +import sys +import tempfile +import types +from frozen import baseline, require +from fraction_table import derive, installed, transformed, Contributions, CAPACITY + + +def types_of(value): + if isinstance(value, dict): + return ('dict', {k:types_of(v) for k,v in value.items()}) + if isinstance(value, (list, tuple)): + return (type(value).__name__, [types_of(v) for v in value]) + return type(value).__name__ + + +def fixtures(): + rng = random.Random(5848) + special = [['ADD',0,1,1,0],['ADD',1,0,1,0],['ADD',1,0,-2,0], + ['ADD',1,0,1,0],['COPY',2,1,-1,0],['SCALE',1,'1/2',0], + ['MOVE',2,0,0,False],['INIT',2,0],['CLEAR',2,0]] + yield dict(public=2,owned_fields=1,program=special), [(F(1),F(1))]*len(special), {'ADD','COPY','SCALE','INIT','CLEAR','MOVE'} + scalars = ['1','-1','1/2','-3/8','2','-4','5/16'] + for case in range(240): + n = 3+case%6 + program = [] + for i in range(case%95): + op = rng.choice(['INIT','CLEAR','MOVE','ADD','COPY','SCALE']) + r = rng.randrange(n) + if op in ('INIT','CLEAR'):event=[op,r,0] + elif op=='MOVE':event=[op,r,0,0,False] + elif op=='SCALE':event=[op,r,rng.choice(scalars),0] + else:event=[op,r,rng.choice([s for s in range(n) if s!=r]),rng.choice(scalars),0] + program.append(event) + weights=[(F(rng.randrange(6),2**rng.randrange(7)),F(rng.randrange(5),2**rng.randrange(6))) for e in program] + rounded={op for op in ('INIT','CLEAR','MOVE','ADD','COPY','SCALE') if rng.randrange(2)} + yield dict(public=n-1,owned_fields=1,program=program),weights,rounded + + +def main(): + results=[] + def rejects(label, action, exception=ValueError): + try:action() + except exception:results.append(label) + else:raise ValueError('accepted '+label) + with baseline() as package: + sys.path.insert(0,str(package)) + import source + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('finite_precision_entry',p/'verify.py') + v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,original,ref): + old=ref.error_trace + fast=derive(ref) + cases=list(fixtures());events=0 + engines={capacity:derive(ref,capacity) for capacity in (0,1,2,CAPACITY)} + for word,weights,rounded in cases: + before=deepcopy((word,weights,rounded)) + a=old(word,weights,rounded) + for capacity in (0,1,2,CAPACITY): + f=engines[capacity];b=f(word,weights,rounded) + require(a==b and types_of(a)==types_of(b),'complete finite output and numeric types') + require(f.statistics()['resident']<=capacity,'bounded per-trace table') + require((word,weights,rounded)==before,'inputs remain unchanged') + events+=len(word['program']) + word,weights,rounded=cases[0] + value=fast(word,weights,rounded);value[0]['final_scores'][0][0]=F(999) + require(fast(word,weights,rounded)==old(word,weights,rounded),'fresh mutable output') + results.append('returned-mutation-isolated') + raw=inspect.getsource(old) + rejects('source-drift',lambda:transformed(raw+'\n# drift\n')) + saved_F=ref.F;ref.F=int + try:rejects('Fraction-type-drift',lambda:derive(ref)) + finally:ref.F=saved_F + with tempfile.TemporaryDirectory() as td: + file=Path(td)/'precision.py';file.write_bytes(Path(ref.__file__).read_bytes()+b'\n# drift\n') + saved_file=ref.__file__;ref.__file__=str(file) + try:rejects('module-byte-drift',lambda:derive(ref)) + finally:ref.__file__=saved_file + code=old.__code__.replace(co_consts=('live-code-drift',)+old.__code__.co_consts[1:]) + ref.error_trace=types.FunctionType(code,old.__globals__) + try:rejects('live-code-drift',lambda:derive(ref)) + finally:ref.error_trace=old + constants=list(old.__code__.co_consts) + index=next(i for i,c in enumerate(constants) if isinstance(c,types.CodeType)) + constants[index]=constants[index].replace(co_consts=constants[index].co_consts+('nested-code-drift',)) + ref.error_trace=types.FunctionType(old.__code__.replace(co_consts=tuple(constants)),old.__globals__) + try:rejects('nested-live-code-drift',lambda:derive(ref)) + finally:ref.error_trace=old + for label,change in [ + ('omitted-witness',('witness[k] = dict(rows[r])','witness[k] = {}')), + ('omitted-rounded-sites',('if op in rounded:','if False:'))]: + text=transformed(raw);require(change[0] in text,'mutant site');text=text.replace(*change) + ns=dict(ref.__dict__);ns.update(_contribution_factory=Contributions,_contribution_report=lambda value:None) + exec(compile(text,'','exec'),ns) + require(any(ns['error_trace'](*c)!=old(*c) for c in cases),'mutant rejected '+label) + results.append(label) + correct_compute=Contributions.compute + for label,index in [('wrong-coefficient',0),('wrong-weighted-increment',1)]: + def corrupted(*args,**kwargs): + out=list(correct_compute(*args,**kwargs));out[index]+=F(1);return tuple(out) + Contributions.compute=staticmethod(corrupted) + try:require(any(fast(*c)!=old(*c) for c in cases),'arithmetic mutant rejected '+label) + finally:Contributions.compute=staticmethod(correct_compute) + results.append(label) + for label,bad_word,bad_weights in [('bad-role',dict(public=2,owned_fields=0,program=[['ADD',99,0,1,0]]),[(F(1),F(1))]),('bad-scalar',dict(public=2,owned_fields=0,program=[['ADD',0,1,'bad',0]]),[(F(1),F(1))]),('missing-weight',word,[])]: + errors=[] + for fn in (old,fast): + try:fn(bad_word,bad_weights,rounded) + except (IndexError,ValueError) as e:errors.append((type(e).__name__,str(e))) + else:raise ValueError('missing original exception '+label) + require(errors[0]==errors[1],'same original exception '+label);results.append(label) + with installed(ref) as f: + require(ref.error_trace is f and f(*cases[0])==old(*cases[0]),'scoped install') + require(ref.error_trace is old,'restore on success');results.append('restore-success') + try: + with installed(ref):raise RuntimeError('caller-failure') + except RuntimeError:pass + require(ref.error_trace is old,'restore on exception');results.append('restore-exception') + require(derive(ref)(*cases[0])==old(*cases[0]),'fresh derivation');results.append('fresh-derivation') + # Complete exact keys, collision safety, FIFO, exceptions and fresh lifetimes. + base=(F(0),F(1),F(1),F(2),F(3)) + for field in range(5): + c=Contributions(4);c.step(*base);c.step(*base) + changed=list(base);changed[field]+=F(1,2) + require(c.step(*changed)==correct_compute(*changed),'complete key value') + require(c.hits==1 and c.misses==2,'every key field bound') + results.append('key-field-'+str(field)) + c=Contributions(2);a=base;b=(F(1),*base[1:]);d=(F(2),*base[1:]) + c.step(*a);c.step(*b);c.step(*a);c.step(*d) + require(c.evictions==1 and len(c.table)==2,'capacity eviction') + prior=c.misses;c.step(*a);require(c.misses==prior+1,'FIFO eviction recomputes');results.append('FIFO-eviction') + c=Contributions(2);c.step(*base) + same=(F(0,2),F(2,2),F(3,3),F(4,2),F(9,3));c.step(*same) + require(c.hits==1,'canonical equal-value key');results.append('canonical-key') + modulus=sys.hash_info.modulus + one=base;two=(F(modulus),*base[1:]);keys=lambda values:tuple(t for x in values for t in (x.numerator,x.denominator)) + require(hash(keys(one))==hash(keys(two)) and keys(one)!=keys(two),'actual hash-collision fixture') + c=Contributions(2);require(c.step(*one)!=c.step(*two) and c.misses==2,'full equality after hash collision');results.append('hash-collision') + c=Contributions(0);c.step(*base);c.step(*base);require(not c.table and c.bypasses==2,'disabled table');results.append('disabled') + for cap in (-1,CAPACITY+1,True,1.5):rejects('invalid-capacity-'+str(cap),lambda cap=cap:Contributions(cap)) + class Explodes: + def __mul__(self,value):raise ArithmeticError('uncached failure') + c=Contributions(2) + for attempt in range(2):rejects('uncached-exception-'+str(attempt),lambda:c.step(F(0),Explodes(),F(1),F(1),F(1)),ArithmeticError) + require(not c.table,'exceptions not cached') + fast(*cases[0]);first=fast.statistics();fast(*cases[0]);require(first==fast.statistics(),'fresh per-call table counters');results.append('fresh-call-table') + first['hits']=-1;require(fast.statistics()['hits']>=0,'stats mutation isolated');results.append('stats-mutation') + try:fast(dict(public=1,owned_fields=0,program=[['ADD',99,0,1,0]]),[(F(1),F(1))],{'ADD'}) + except IndexError:pass + else:raise ValueError('missing original failed-call exception') + require(fast.statistics() is None,'failed call has no old accepted stats');results.append('failed-call-clears-stats') + require(len(results)==34,'finite control census') + result={'status':'PASS_FINITE_FRACTION_TABLE_FEASIBILITY','cases':len(cases),'events':events,'controls':results,'all_complete_values_and_types_equal':True} + print(json.dumps(result,sort_keys=True)) + return result +if __name__=='__main__':main() diff --git a/research/fraction-native-qualification/slot_binding.py b/research/fraction-native-qualification/slot_binding.py new file mode 100644 index 0000000000..e226fd730e --- /dev/null +++ b/research/fraction-native-qualification/slot_binding.py @@ -0,0 +1,53 @@ +"""Bind only pure Fraction key getters and exact owned slots; never arithmetic.""" +from fractions import Fraction as F +from hashlib import sha256 +import json +from pathlib import Path +from types import FunctionType,MemberDescriptorType +from table_parent import code_shape + +EXPECTED=json.loads(Path(__file__).with_name('GETTER-SHAPES.json').read_text()) + + +def snapshot(): + try: + result=[] + for name in ('numerator','denominator'): + prop=F.__dict__.get(name);slot=F.__dict__.get('_'+name) + if type(prop) is not property or type(prop.fget) is not FunctionType or type(slot) is not MemberDescriptorType: + return None + fn=prop.fget + result.extend((prop,fn,fn.__code__,fn.__defaults__,fn.__kwdefaults__,fn.__closure__,slot)) + for cls in F.__mro__: + result.extend((cls,'__getattribute__' in cls.__dict__,cls.__dict__.get('__getattribute__'),'__getattr__' in cls.__dict__,cls.__dict__.get('__getattr__'))) + return tuple(result) + except (AttributeError,TypeError,ValueError):return None + + +def fresh(token): + now=snapshot() + return token is not None and now is not None and len(token)==len(now) and all(a is b for a,b in zip(token,now)) + + +def bind(strict=False): + try: + if any('__getattr__' in cls.__dict__ for cls in F.__mro__): + raise ValueError('no foreign missing-attribute fallback') + for name,expected in EXPECTED.items(): + prop=F.__dict__.get(name);slot=F.__dict__.get('_'+name) + if type(prop) is not property or type(prop.fget) is not FunctionType or type(slot) is not MemberDescriptorType: + raise ValueError('standard getter and owned slot '+name) + fn=prop.fget + if fn.__defaults__ is not None or fn.__kwdefaults__ is not None or fn.__closure__ is not None: + raise ValueError('pure getter has no defaults or closure') + if fn.__code__.co_names!=('_'+name,) or sha256(repr(code_shape(fn.__code__)).encode()).hexdigest()!=expected: + raise ValueError('exact getter executable '+name) + if slot.__objclass__ is not F or slot.__name__!='_'+name: + raise ValueError('slot belongs to this exact Fraction class') + accessor=next((c.__dict__['__getattribute__'] for c in F.__mro__ if '__getattribute__' in c.__dict__),None) + if accessor is not object.__dict__['__getattribute__']: + raise ValueError('ordinary object attribute lookup') + return snapshot() + except (ValueError,AttributeError,TypeError,KeyError) as error: + if strict:raise ValueError('unsupported Fraction key getters: '+str(error)) from error + return None diff --git a/research/fraction-native-qualification/slot_finite.py b/research/fraction-native-qualification/slot_finite.py new file mode 100644 index 0000000000..3231246efe --- /dev/null +++ b/research/fraction-native-qualification/slot_finite.py @@ -0,0 +1,75 @@ +"""Inherited complete key/table/entry tests plus getter/fallback controls.""" +import importlib.util,json,sys +from fractions import Fraction as F +import compact_finite +from frozen import baseline,require +from compact_finite import types_of +import fraction_table as table +import slot_binding as binding + + +def main(): + inherited=compact_finite.main();controls=[] + token=binding.bind(strict=True);require(binding.fresh(token),'known getter binding') + numerator=F.__dict__['numerator'];slot=F.__dict__['_numerator'] + F.numerator=property(lambda self:self._numerator+1) + try:require(binding.bind() is None and not binding.fresh(token),'getter replacement invalidates') + finally:F.numerator=numerator + controls.append('changed-getter-invalidates') + code=numerator.fget.__code__;numerator.fget.__code__=code.replace(co_consts=code.co_consts+('drift',)) + try:require(binding.bind() is None and not binding.fresh(token),'live getter code invalidates') + finally:numerator.fget.__code__=code + controls.append('changed-live-getter-code') + calls=[] + class Foreign: + def __get__(self,*args):calls.append(True);raise RuntimeError('foreign descriptor must not run') + F._numerator=Foreign() + try:require(binding.bind() is None and not binding.fresh(token) and not calls,'foreign slot rejected without invocation') + finally:F._numerator=slot + controls.append('foreign-slot-probe-is-pure') + F.__getattribute__=lambda self,name:object.__getattribute__(self,name) + try:require(binding.bind() is None and not binding.fresh(token),'custom attribute lookup rejected') + finally:del F.__getattribute__ + controls.append('changed-attribute-lookup') + F.__getattr__=None + try:require(binding.bind() is None and not binding.fresh(token),'present None getattr rejected') + finally:del F.__getattr__ + controls.append('missing-attribute-handler-presence') + require(binding.fresh(token),'runtime fully restored') + controls.append('binding-restored') + with baseline() as package: + sys.path.insert(0,str(package));spec=importlib.util.spec_from_file_location('slot_bundle',package/'source.py') + source=importlib.util.module_from_spec(spec);spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('slot_finite_source',p/'verify.py');v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,_,ref): + original=ref.error_trace + fixture=(dict(public=4,owned_fields=0,program=[['INIT',0,0],['INIT',1,0],['ADD',2,0,1,0],['ADD',3,1,1,0]]),[(F(1),F(2)),(F(3),F(5)),(F(7),F(11)),(F(13),F(17))],{'INIT'}) + fast=table.derive(ref);a=fast(*fixture);b=original(*fixture) + require(a==b and types_of(a)==types_of(b) and fast.compacted_selected() is True,'slot path used with all outputs preserved') + controls.append('slot-path-selected') + getter_calls=[] + def observed_getter(self): + getter_calls.append(True);return self._numerator + F.numerator=property(observed_getter) + try: + a=fast(*fixture);count_a=len(getter_calls);getter_calls.clear() + b=original(*fixture);count_b=len(getter_calls) + require(a==b and count_a==count_b and fast.compacted_selected() is False,'post-derive getter drift uses literal source and same calls') + finally:F.numerator=numerator + controls.append('post-derive-getter-drift-literal-fallback') + uninitialized=object.__new__(F) + word=dict(public=1,owned_fields=0,program=[]);weights=[(uninitialized,F(1))] + fast=table.derive(ref) + require(fast(word,weights,set())==original(word,weights,set()) and fast.compacted_selected() is False,'unused malformed Fraction does not introduce an exception') + controls.append('uninitialized-unused-weight-fallback') + class ForeignInteger: + def __hash__(self):raise RuntimeError('foreign key hash must not run') + corrupt=object.__new__(F);corrupt._numerator=ForeignInteger();corrupt._denominator=1 + weights=[(corrupt,F(1))] + require(fast(word,weights,set())==original(word,weights,set()) and fast.compacted_selected() is False,'corrupt unused slot values do not run custom hash') + controls.append('foreign-slot-value-fallback') + result=dict(status='PASS_SLOT_KEY_FINITE_ONLY',inherited=inherited,new_controls=controls,new_control_count=len(controls),all_coverage_preserved=True) + print(json.dumps(result,sort_keys=True));return result + +if __name__=='__main__':main() diff --git a/research/fraction-native-qualification/slot_parent.py b/research/fraction-native-qualification/slot_parent.py new file mode 100644 index 0000000000..5a77bebfe0 --- /dev/null +++ b/research/fraction-native-qualification/slot_parent.py @@ -0,0 +1,85 @@ +"""Same compact keys with verified pure property-to-slot equivalence.""" +from contextlib import contextmanager +from hashlib import sha256 +import inspect +from pathlib import Path +import compact_parent as parent +from slot_binding import bind,fresh + +F=parent.F;CAPACITY=parent.CAPACITY +Contributions=parent.Contributions +NORMAL_CONTRIBUTIONS=Contributions +certified_domain=parent.certified_domain +transformed=parent.transformed +def weight_tokens(weights,limit=parent.CONTEXT_CAPACITY): + parent.entry.parent.need(type(limit) is int and 0<=limit<=parent.CONTEXT_CAPACITY,'bounded context token capacity') + mapping={};tokens=[] + for row in weights: + a,c=row[0],row[1] + if type(a) is not F or type(c) is not F:return None + try:key=(a._numerator,a._denominator,c._numerator,c._denominator) + except AttributeError:return None + if any(type(x) is not int for x in key) or key[1]<=0 or key[3]<=0:return None + token=mapping.get(key) + if token is None: + if len(mapping)>=limit:return None + token=len(mapping);mapping[key]=token + tokens.append(token) + return tokens + + +class CompactContributions(parent.CompactContributions): + def event(self,q): + qn,qd=q.numerator,q.denominator + table=self.table;weights=self.weights;tokens=self.tokens;capacity=self.capacity;compute=self.compute + def step(old,v,i): + self.calls+=1 + key=(old._numerator,old._denominator,qn,qd,v._numerator,v._denominator,tokens[i]) + result=table.get(key) + if result is not None:self.hits+=1;return result + self.misses+=1 + result=compute(old,q,v,weights[i][0],weights[i][1]) + if len(table)>=capacity:table.popitem(last=False);self.evictions+=1 + table[key]=result + return result + return step + + +def derive(reference,capacity=CAPACITY): + entry=parent.entry;source=entry.parent + source.need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + source.need(reference.F is F,'exact standard Fraction type') + source.need(sha256(Path(reference.__file__).read_bytes()).hexdigest()==source.MODULE_SHA256,'exact Fraction module bytes') + original=reference.error_trace;raw=inspect.getsource(original) + safe=transformed(raw);compact=parent.compact_text(raw) + namespace=dict(reference.__dict__);exec(compile(raw,'','exec'),namespace) + source.need(source.code_shape(original.__code__)==source.code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + source.need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + token=bind();last=[None,None,None];factory=Contributions + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:factory(capacity),_contribution_report=report, + _compact_factory=lambda weights,tokens:CompactContributions(capacity,weights,tokens)) + exec(compile(safe,'','exec'),namespace);generic=namespace['error_trace'] + exec(compile(compact,'','exec'),namespace);specialized=namespace['error_trace'] + def call(word,weights,rounded): + if token is None or not fresh(token): + last[:]=[None,False,None] + return original(word,weights,rounded) + eligible=bool(capacity and factory is NORMAL_CONTRIBUTIONS and certified_domain(word,weights,rounded)) + tokens=weight_tokens(weights) if eligible else None + if eligible and tokens is None: + last[:]=[None,False,None] + return original(word,weights,rounded) + last[1]=tokens is not None;last[2]=None if tokens is None else (max(tokens)+1 if tokens else 0) + return specialized(word,weights,rounded,tokens) if tokens is not None else generic(word,weights,rounded) + call.statistics=lambda:None if last[0] is None else dict(last[0]) + call.compacted_selected=lambda:last[1] + call.token_count=lambda:last[2] + return call + + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace;derived=derive(reference,capacity);reference.error_trace=derived + try:yield derived + finally:reference.error_trace=original diff --git a/research/fraction-native-qualification/table_parent.py b/research/fraction-native-qualification/table_parent.py new file mode 100644 index 0000000000..7f44b25859 --- /dev/null +++ b/research/fraction-native-qualification/table_parent.py @@ -0,0 +1,123 @@ +"""Per-trace bounded tabulation of pure exact Fraction contributions. + +Original arithmetic: Ali Romman and retained completed-error lineage. +New table/derivation: Chris R / Clear1nsight, substantial OpenAI Codex assistance. +Apache-2.0. No approximate or shared integer-backend arithmetic. +""" +from contextlib import contextmanager +from collections import OrderedDict +from fractions import Fraction as F +from hashlib import sha256 +import inspect +from pathlib import Path +from types import CodeType + +MODULE_SHA256='a4c743e79c55e9c2ac26deb6d87cb948b1b0fbe942e4f7912ccbfba55db4b32a' +FUNCTION_SHA256='379c0e7c1c5ab7433ab5ad2669c1bda1234dbf0530fc61b21bfbe83528f37f53' +CAPACITY=16384 +BEFORE=''' value = old + q*v + change = abs(value)-abs(old) + scores[r][0] += change*weights[i][0] + scores[r][1] += change*weights[i][1] + scores[r][2] += change +''' +AFTER=''' value, increment_a, increment_c, change = contributions.step( + old, q, v, weights[i][0], weights[i][1]) + scores[r][0] += increment_a + scores[r][1] += increment_c + scores[r][2] += change +''' + + +def need(ok,message): + if not ok: + raise ValueError(message) + + +class Contributions: + def __init__(self,capacity=CAPACITY): + need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + self.capacity=capacity + self.table=OrderedDict() + self.calls=self.hits=self.misses=self.evictions=self.bypasses=0 + + @staticmethod + def compute(old,q,v,a,c): + value=old+q*v + change=abs(value)-abs(old) + return value,change*a,change*c,change + + def step(self,old,q,v,a,c): + self.calls+=1 + if not self.capacity or not all(type(x) is F for x in (old,q,v,a,c)): + self.bypasses+=1 + return self.compute(old,q,v,a,c) + key=(old.numerator,old.denominator,q.numerator,q.denominator, + v.numerator,v.denominator,a.numerator,a.denominator,c.numerator,c.denominator) + result=self.table.get(key) + if result is not None: + self.hits+=1 + return result + self.misses+=1 + result=self.compute(old,q,v,a,c) + if len(self.table)>=self.capacity: + self.table.popitem(last=False) + self.evictions+=1 + self.table[key]=result + return result + + def statistics(self): + return dict(calls=self.calls,hits=self.hits,misses=self.misses, + evictions=self.evictions,bypasses=self.bypasses, + resident=len(self.table),capacity=self.capacity) + + +def code_shape(code): + constants=tuple(code_shape(c) if isinstance(c,CodeType) else c for c in code.co_consts) + return (code.co_code,constants,code.co_names,code.co_varnames,code.co_argcount, + code.co_posonlyargcount,code.co_kwonlyargcount,code.co_flags, + code.co_freevars,code.co_cellvars,code.co_name,code.co_stacksize, + code.co_nlocals,code.co_exceptiontable) + + +def transformed(raw): + need(sha256(raw.encode()).hexdigest()==FUNCTION_SHA256,'exact Fraction function source') + need(raw.count(BEFORE)==1,'one exact Fraction contribution block') + value=raw.replace(BEFORE,AFTER) + seam=" n = word['public'] + word['owned_fields']\n" + need(value.count(seam)==1,'one exact Fraction setup seam') + value=value.replace(seam,seam+' _contribution_report(None)\n contributions = _contribution_factory()\n') + seam=' return dict(rounded=sorted(rounded), sites=sites, peaks=peaks, pareto=pareto,\n' + need(value.count(seam)==1,'one exact Fraction return seam') + return value.replace(seam,' _contribution_report(contributions.statistics())\n'+seam) + + +def derive(reference,capacity=CAPACITY): + need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + need(reference.F is F,'exact standard Fraction type') + need(sha256(Path(reference.__file__).read_bytes()).hexdigest()==MODULE_SHA256,'exact Fraction module bytes') + original=reference.error_trace + raw=inspect.getsource(original) + text=transformed(raw) + namespace=dict(reference.__dict__) + exec(compile(raw,'','exec'),namespace) + need(code_shape(original.__code__)==code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + last=[None] + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:Contributions(capacity),_contribution_report=report) + exec(compile(text,'','exec'),namespace) + result=namespace['error_trace'] + result.statistics=lambda:None if last[0] is None else dict(last[0]) + return result + + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace + derived=derive(reference,capacity) + reference.error_trace=derived + try: + yield derived + finally: + reference.error_trace=original From 8f04865e903eead8730be622357e3604c6fea179 Mon Sep 17 00:00:00 2001 From: d3lerium Date: Tue, 27 Oct 2026 20:19:01 +1100 Subject: [PATCH 3/4] Reduce complete precision qualification by19percent with source-bound C bookkeeping --- .../fraction-native-qualification/.gitignore | 3 + .../NATIVE-SOURCE.json | 3 + research/fraction-native-qualification/NOTICE | 9 + .../fraction-native-qualification/PROOF.md | 37 +++ .../fraction-native-qualification/README.md | 62 +++++ .../fraction-native-qualification/RESULT.json | 154 ++++++++++++ .../SOURCES.json | 120 +++++++++ .../fraction-native-qualification/TASK.json | 60 +++++ .../VALIDATION.json | 72 ++++++ .../fraction-native-qualification/VERIFY.json | 31 +++ .../actual_audit.py | 32 +++ .../benchmark.py | 46 ++++ .../fraction-native-qualification/custody.py | 19 ++ .../evidence/FINITE-INERT-GC-FIXTURE.py.txt | 13 + .../evidence/HARNESS-CORRECTION.json | 13 + .../NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md | 65 +++++ .../evidence/NATIVE-CACHE-REVIEW-SOURCES.json | 28 +++ .../evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md | 51 ++++ .../evidence/NATIVE-REVIEW-FINAL-STATE.json | 33 +++ .../evidence/PLAN.json | 22 ++ .../evidence/SCREEN.json | 29 +++ .../fraction-compact-key-20261027/SCREEN.json | 50 ++++ .../fraction-compact-key-20261027/STATE.json | 57 +++++ .../micro-compact-key/receipt.json | 26 ++ .../micro-compact-key/stderr.txt | 0 .../micro-compact-key/stdout.txt | 1 + .../micro-compact-key/usage.json | 1 + .../HARNESS-CORRECTION.json | 6 + .../fraction-direct-add-20261027/SCREEN.json | 9 + .../fraction-direct-add-20261027/STATE.json | 7 + .../micro-direct-add/receipt.json | 26 ++ .../micro-direct-add/stderr.txt | 0 .../micro-direct-add/stdout.txt | 1 + .../micro-direct-add/usage.json | 1 + .../HARNESS-CORRECTION.json | 8 + .../fraction-slot-key-20261027/STATE.json | 5 + .../micro-slot-key/receipt.json | 26 ++ .../micro-slot-key/stderr.txt | 0 .../micro-slot-key/stdout.txt | 1 + .../micro-slot-key/usage.json | 1 + .../evidence/runtime/GATE-2.json | 22 ++ .../evidence/runtime/GATE-6.json | 26 ++ .../evidence/runtime/benchmark.py | 40 +++ .../evidence/runtime/dispatch.py | 14 ++ .../evidence/runtime/guard.py | 120 +++++++++ .../evidence/runtime/runs/B1/receipt.json | 26 ++ .../evidence/runtime/runs/B1/stderr.txt | 0 .../evidence/runtime/runs/B1/stdout.txt | 3 + .../evidence/runtime/runs/B1/usage.json | 1 + .../evidence/runtime/runs/B2/receipt.json | 26 ++ .../evidence/runtime/runs/B2/stderr.txt | 0 .../evidence/runtime/runs/B2/stdout.txt | 3 + .../evidence/runtime/runs/B2/usage.json | 1 + .../evidence/runtime/runs/B3/receipt.json | 26 ++ .../evidence/runtime/runs/B3/stderr.txt | 0 .../evidence/runtime/runs/B3/stdout.txt | 3 + .../evidence/runtime/runs/B3/usage.json | 1 + .../evidence/runtime/runs/C1/receipt.json | 26 ++ .../evidence/runtime/runs/C1/stderr.txt | 0 .../evidence/runtime/runs/C1/stdout.txt | 9 + .../evidence/runtime/runs/C1/usage.json | 1 + .../evidence/runtime/runs/C2/receipt.json | 26 ++ .../evidence/runtime/runs/C2/stderr.txt | 0 .../evidence/runtime/runs/C2/stdout.txt | 9 + .../evidence/runtime/runs/C2/usage.json | 1 + .../evidence/runtime/runs/C3/receipt.json | 26 ++ .../evidence/runtime/runs/C3/stderr.txt | 0 .../evidence/runtime/runs/C3/stdout.txt | 9 + .../evidence/runtime/runs/C3/usage.json | 1 + .../runs/actual-native-apply/receipt.json | 26 ++ .../runs/actual-native-apply/stderr.txt | 0 .../runs/actual-native-apply/stdout.txt | 1 + .../runs/actual-native-apply/usage.json | 1 + .../runs/apply-micro-native/receipt.json | 26 ++ .../runs/apply-micro-native/stderr.txt | 0 .../runs/apply-micro-native/stdout.txt | 1 + .../runs/apply-micro-native/usage.json | 1 + .../runtime/runs/finite-native-O/receipt.json | 26 ++ .../runtime/runs/finite-native-O/stderr.txt | 0 .../runtime/runs/finite-native-O/stdout.txt | 5 + .../runtime/runs/finite-native-O/usage.json | 1 + .../finite-native-bound-debug/receipt.json | 26 ++ .../runs/finite-native-bound-debug/stderr.txt | 0 .../runs/finite-native-bound-debug/stdout.txt | 5 + .../runs/finite-native-bound-debug/usage.json | 1 + .../finite-native-cleanup-debug/receipt.json | 26 ++ .../finite-native-cleanup-debug/stderr.txt | 0 .../finite-native-cleanup-debug/stdout.txt | 5 + .../finite-native-cleanup-debug/usage.json | 1 + .../finite-native-debug-cleanup/receipt.json | 26 ++ .../finite-native-debug-cleanup/stderr.txt | 0 .../finite-native-debug-cleanup/stdout.txt | 5 + .../finite-native-debug-cleanup/usage.json | 1 + .../runs/finite-native-debug/receipt.json | 26 ++ .../runs/finite-native-debug/stderr.txt | 2 + .../runs/finite-native-debug/stdout.txt | 5 + .../runs/finite-native-debug/usage.json | 1 + .../finite-native-final-debug/receipt.json | 26 ++ .../runs/finite-native-final-debug/stderr.txt | 0 .../runs/finite-native-final-debug/stdout.txt | 5 + .../runs/finite-native-final-debug/usage.json | 1 + .../runs/finite-native-initial/receipt.json | 26 ++ .../runs/finite-native-initial/stderr.txt | 0 .../runs/finite-native-initial/stdout.txt | 5 + .../runs/finite-native-initial/usage.json | 1 + .../runs/finite-native-packet-O/receipt.json | 23 ++ .../runs/finite-native-packet-O/stderr.txt | 8 + .../runs/finite-native-packet-O/stdout.txt | 4 + .../runs/finite-native-packet-O/usage.json | 2 + .../finite-native-reviewed-O/receipt.json | 26 ++ .../runs/finite-native-reviewed-O/stderr.txt | 0 .../runs/finite-native-reviewed-O/stdout.txt | 5 + .../runs/finite-native-reviewed-O/usage.json | 1 + .../finite-native-snapshot-O/receipt.json | 26 ++ .../runs/finite-native-snapshot-O/stderr.txt | 0 .../runs/finite-native-snapshot-O/stdout.txt | 5 + .../runs/finite-native-snapshot-O/usage.json | 1 + .../runtime/runs/full-native-O/receipt.json | 26 ++ .../runtime/runs/full-native-O/stderr.txt | 0 .../runtime/runs/full-native-O/stdout.txt | 9 + .../runtime/runs/full-native-O/usage.json | 1 + .../runtime/runs/micro-native/receipt.json | 26 ++ .../runtime/runs/micro-native/stderr.txt | 0 .../runtime/runs/micro-native/stdout.txt | 1 + .../runtime/runs/micro-native/usage.json | 1 + .../packaged-native-finite-O/receipt.json | 26 ++ .../runs/packaged-native-finite-O/stderr.txt | 0 .../runs/packaged-native-finite-O/stdout.txt | 7 + .../runs/packaged-native-finite-O/usage.json | 1 + .../runs/packaged-native-finite/receipt.json | 26 ++ .../runs/packaged-native-finite/stderr.txt | 0 .../runs/packaged-native-finite/stdout.txt | 7 + .../runs/packaged-native-finite/usage.json | 1 + .../fraction-native-qualification/finite.py | 146 +++++++++++ .../fraction_table.py | 118 +++++++++ .../fraction-native-qualification/full.py | 54 +++++ .../fraction-native-qualification/full_B.py | 2 + .../fraction-native-qualification/full_C.py | 2 + .../fraction-native-qualification/guard.py | 120 +++++++++ .../fraction-native-qualification/micro.py | 20 ++ .../micro_apply.py | 29 +++ .../native_backend.py | 61 +++++ .../native_cache.c | 227 ++++++++++++++++++ .../fraction-native-qualification/replay.py | 13 + .../replay_driver.py | 9 + .../fraction-native-qualification/verify.py | 14 ++ 146 files changed, 2878 insertions(+) create mode 100644 research/fraction-native-qualification/.gitignore create mode 100644 research/fraction-native-qualification/NATIVE-SOURCE.json create mode 100644 research/fraction-native-qualification/NOTICE create mode 100644 research/fraction-native-qualification/PROOF.md create mode 100644 research/fraction-native-qualification/README.md create mode 100644 research/fraction-native-qualification/RESULT.json create mode 100644 research/fraction-native-qualification/SOURCES.json create mode 100644 research/fraction-native-qualification/TASK.json create mode 100644 research/fraction-native-qualification/VALIDATION.json create mode 100644 research/fraction-native-qualification/VERIFY.json create mode 100644 research/fraction-native-qualification/actual_audit.py create mode 100644 research/fraction-native-qualification/benchmark.py create mode 100644 research/fraction-native-qualification/custody.py create mode 100644 research/fraction-native-qualification/evidence/FINITE-INERT-GC-FIXTURE.py.txt create mode 100644 research/fraction-native-qualification/evidence/HARNESS-CORRECTION.json create mode 100644 research/fraction-native-qualification/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md create mode 100644 research/fraction-native-qualification/evidence/NATIVE-CACHE-REVIEW-SOURCES.json create mode 100644 research/fraction-native-qualification/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md create mode 100644 research/fraction-native-qualification/evidence/NATIVE-REVIEW-FINAL-STATE.json create mode 100644 research/fraction-native-qualification/evidence/PLAN.json create mode 100644 research/fraction-native-qualification/evidence/SCREEN.json create mode 100644 research/fraction-native-qualification/evidence/fraction-compact-key-20261027/SCREEN.json create mode 100644 research/fraction-native-qualification/evidence/fraction-compact-key-20261027/STATE.json create mode 100644 research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json create mode 100644 research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json create mode 100644 research/fraction-native-qualification/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json create mode 100644 research/fraction-native-qualification/evidence/fraction-direct-add-20261027/SCREEN.json create mode 100644 research/fraction-native-qualification/evidence/fraction-direct-add-20261027/STATE.json create mode 100644 research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json create mode 100644 research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json create mode 100644 research/fraction-native-qualification/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json create mode 100644 research/fraction-native-qualification/evidence/fraction-slot-key-20261027/STATE.json create mode 100644 research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json create mode 100644 research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/GATE-2.json create mode 100644 research/fraction-native-qualification/evidence/runtime/GATE-6.json create mode 100644 research/fraction-native-qualification/evidence/runtime/benchmark.py create mode 100644 research/fraction-native-qualification/evidence/runtime/dispatch.py create mode 100644 research/fraction-native-qualification/evidence/runtime/guard.py create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B1/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B1/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B1/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B1/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B2/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B2/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B2/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B2/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B3/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B3/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B3/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/B3/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C1/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C1/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C1/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C1/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C2/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C2/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C2/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C2/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C3/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C3/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C3/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/C3/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/full-native-O/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/full-native-O/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/micro-native/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/micro-native/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/micro-native/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/micro-native/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/usage.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/receipt.json create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/usage.json create mode 100644 research/fraction-native-qualification/finite.py create mode 100644 research/fraction-native-qualification/fraction_table.py create mode 100644 research/fraction-native-qualification/full.py create mode 100644 research/fraction-native-qualification/full_B.py create mode 100644 research/fraction-native-qualification/full_C.py create mode 100644 research/fraction-native-qualification/guard.py create mode 100644 research/fraction-native-qualification/micro.py create mode 100644 research/fraction-native-qualification/micro_apply.py create mode 100644 research/fraction-native-qualification/native_backend.py create mode 100644 research/fraction-native-qualification/native_cache.c create mode 100644 research/fraction-native-qualification/replay.py create mode 100644 research/fraction-native-qualification/replay_driver.py create mode 100644 research/fraction-native-qualification/verify.py diff --git a/research/fraction-native-qualification/.gitignore b/research/fraction-native-qualification/.gitignore new file mode 100644 index 0000000000..4446e4135a --- /dev/null +++ b/research/fraction-native-qualification/.gitignore @@ -0,0 +1,3 @@ +__pycache__/ +work/ +*.so diff --git a/research/fraction-native-qualification/NATIVE-SOURCE.json b/research/fraction-native-qualification/NATIVE-SOURCE.json new file mode 100644 index 0000000000..793edb7fd8 --- /dev/null +++ b/research/fraction-native-qualification/NATIVE-SOURCE.json @@ -0,0 +1,3 @@ +{ + "sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb" +} diff --git a/research/fraction-native-qualification/NOTICE b/research/fraction-native-qualification/NOTICE new file mode 100644 index 0000000000..3cd6a81a60 --- /dev/null +++ b/research/fraction-native-qualification/NOTICE @@ -0,0 +1,9 @@ +Fraction arithmetic primitive profile and bounded contribution-table feasibility +============================================================================ +Original Fraction/error arithmetic: Ali Romman, retaining Adam Gall/ywz65/PR2878, PR5826/5819, Mason Hale/PR5811 and all P104/native/compiler/precision notices. Full PR5848, PR5831 and nested source archives are unchanged. Apache-2.0. + +New primitive profiling, exact local table, finite/key/capacity/failure checks and complete-cost screen: Chris R / Clear1nsight, substantial OpenAI Codex assistance; no subagents or independent human/kernel acceptance. Memoization is a standard technique. PR5848/5839 supply the qualifier/Linux baseline; PR5816/5818/5832/5761 retain tooling and test-repair credit with original authorship. The prior zero/unit negative artifact71f22c77b393e5cc14925c771894dc1a92c8443c supplies source-binding and finite-fixture lineage. No complete performance or kappa improvement is claimed. + +Source-bound entry type gate: Chris R / Clear1nsight with substantial OpenAI Codex assistance; no independent human or proof-kernel acceptance. Parent table/finite bytes retained exactly from df9dc4c89b31494f1390d16b9ca2a15e5946e853 (PR5852). Publication agents handled only earlier branches, not this scientific test. + +Native cache/context, source-bound slot/compact-key integration and complete cold-build qualifier: Chris R / Clear1nsight with substantial OpenAI Codex assistance and GPT-6-astra xhigh static review. The original Fraction miss arithmetic and independent exact integer engine are unchanged. C API/reference-counting/memoization are standard techniques. Preserve all inherited authors and Apache-2.0 notices. The C helper is new code; it does not port CPython arithmetic. Local measured timings are not a universal speedup or hosted performance validation. No kappa claim. diff --git a/research/fraction-native-qualification/PROOF.md b/research/fraction-native-qualification/PROOF.md new file mode 100644 index 0000000000..98076aaa39 --- /dev/null +++ b/research/fraction-native-qualification/PROOF.md @@ -0,0 +1,37 @@ +# Equivalence and complete-cost obligations + +This is a source-bound implementation argument for the frozen PR5848 qualifier, supported by exact finite/actual comparisons and local cold-process measurements. It is not a formal proof of arbitrary Python callbacks, a multiplication theorem or a kappa admission. + +## Entry domain and arithmetic + +Retain the predecessor's conservative identity-only exact-container/type predicate. For that domain, induction through empty rows, INIT/CLEAR resets, F(1) injections, SCALE and ADD/COPY gives exact Fraction row coefficients. Weights are exact Fractions. Stable standard Fraction operations on exact operands return exact Fractions. Unknown/custom domains retain the checked generic behavior. Native selection additionally requires valid distinct source/destination rows, sufficient source-site metadata, and well-formed exact-Fraction scalar slots; other such cases use the literal original trace so error type/message/order are preserved. + +The canonical numerator/denominator property getters are bound to their pure executable shapes, owned member descriptors and ordinary object attribute lookup. Before each trace, identity/code/presence freshness is rechecked. Getter, slot or lookup drift selects the literal original. The miss callback is extracted from raw class MRO dictionaries only after verifying an exact staticmethod descriptor, exact FunctionType, no closure/defaults, the literal original compute code shape and captured builtin abs. A foreign descriptor is not invoked to inspect it. Nonqualifying callbacks select the checked parent path, allowing retained corruption controls to detect altered arithmetic. + +Each successful miss computes exactly `value = old + q*v`, `change = abs(value)-abs(old)`, then returns `(value, change*a, change*c, change)`, with the original Python Fraction operations. The native helper does not implement rational arithmetic. Cached values are immutable exact-Fraction tuples under the predecessor's stable-input/runtime premise. + +## Complete key and FIFO invariant + +The key is `(old_n,old_d,q_n,q_d,v_n,v_d,weight_token)`. Per-trace tokens are assigned injectively to complete `(a_n,a_d,c_n,c_d)` pairs using full Python integer equality after hash comparison, bounded to 16,384 distinct pairs with no recycling. Equal canonical weights share a token; unequal pairs cannot. Metadata is indexed by original source site i, not event position. Event owns q and its canonical key components. Overflow or invalid metadata selects original behavior. + +Initially dictionary and fixed ring are empty. Each dictionary entry has exactly one owned ring-key reference, with `used` resident entries and `head` at the next insertion/oldest eviction slot. Hits return an owned reference to the dictionary result and do not reorder the ring. A miss increments the same counters and performs original computation before eviction. At capacity, delete the oldest dictionary key and clear its ring reference; then insert and advance. Failed computation never evicts or caches. If insertion itself fails after eviction, the ring/dictionary remain consistent with a smaller cache, and the error propagates. Counters are bounded against C signed overflow. Per-trace Cache objects are fresh; only code is reused in a process. + +## Coefficient-loop correspondence and native ownership + +The complete literal source loop is authenticated before replacement. Native apply uses the actual Python dict-items iterator, preserving order and its size/key mutation errors. Each item tuple holds source index/value strongly across callbacks. Each iteration constructs F(0), obtains the destination's old coefficient, gets the exact contribution tuple, performs the three ordered PyNumber_InPlaceAdd updates and updates/removes the destination exactly as the Python loop. Checked score retrieval and strong temporary references remain safe around Python callbacks. Rounded injection, score peaks, witness capture, stream hashing and return structure remain in the unchanged outer source. + +Cache owns dictionary, ring, immutable metadata snapshots, callback, descriptors and Fraction class. Event owns Cache and q context. Constructor tokens use checked owned reads, not unchecked reads from a mutable caller list across allocations. Partial initialization, error exits, GC traversal/clear/deallocation and Event-outliving-Cache cases are covered by source review and finite checks. A busy guard rejects reentrant mutation; errors reset it. Descriptor reads stop at the first failure. These defenses protect the packet API; the wrapper's semantic qualification is still required. + +The loader authenticates C bytes, copies exactly those bytes into an owned read-only build snapshot and compiles that snapshot. Loaded-code reuse requires the same authenticated source digest. Builds occur in a fresh temporary directory per complete candidate process, with explicit cleanup. Every fresh complete process pays compilation, linking, loading and validation. There is no system installation, persistent compiled-answer cache or native arithmetic shared with the independent integer engine. + +## Complete caller and oracle boundary + +The new full entry authenticates the complete readonly PR5848 export and changes exactly the sole actual noisy_precision error_trace immediately before the existing Observation wrapper. The separately loaded reference/integer engine, source contract, all reverse checks, 120 finite fixtures, six controls, final receipt and original Observation finite tests remain unchanged. Capture by program length is scoped to this exact frozen source, which calls error_trace once; it is not a general caller-identification rule. The full native output digest and exact cache counters are required in addition to the original complete scientific comparisons. + +The new native finite stage runs before the original complete entry in every timed C command. All 964 comparisons / 73 inherited +45 native controls are charged. The four inherited custody checks remain separate registered-verification obligations, just as in the predecessor benchmark. Independent backends do not share mutable caches or answers. Complete normal/O and exported-source replays supplement the finite gate. + +## Economics and limits + +The immutable-code build is shared only between the new finite stage and actual trace inside one process. The complete outer process is measured with GNU time, so compiler/linker child CPU is included. In six fresh serial B,C,C,B,B,C processes, wall medians are 40.516156 and 32.771297 seconds, CPU medians 40.33 and 32.74 seconds: 19.1155% and 18.8197% saved, passing both declared 15% gates. All observations, source inventories, stdout/stderr and failed harness attempts are retained. This evidence is specific to the frozen fixture and recorded Linux/CPython/GCC environment; inner trace timings, cost models and hosted finite replay are distinct claims. + +Static/API review by GPT-6-astra xhigh ran no compiler or numerical replay. Chris R / Clear1nsight with substantial OpenAI Codex assistance performed the single serial numerical execution. Original arithmetic/provenance remains Ali Romman and all retained predecessor authors; see NOTICE. No kappa or selected metadata changes. diff --git a/research/fraction-native-qualification/README.md b/research/fraction-native-qualification/README.md new file mode 100644 index 0000000000..927cbee16a --- /dev/null +++ b/research/fraction-native-qualification/README.md @@ -0,0 +1,62 @@ +# Native bookkeeping for complete PR5848 qualification + +The complete frozen qualifier runs in **32.77 rather than 40.52 seconds median wall time (19.12% less)** and **32.74 rather than 40.33 seconds median CPU (18.82% less)** on this Linux host. Each candidate command includes every new finite/native check and a fresh compile, link and load. Compiler-child CPU is counted. This is a local six-process B,C,C,B,B,C comparison, not a universal speedup or hosted performance result. + +This opt-in package follows [PR #5848](https://github.com/CrocSwap/integer-mult-bounds/pull/5848), [PR #5852](https://github.com/CrocSwap/integer-mult-bounds/pull/5852), [PR #5853](https://github.com/CrocSwap/integer-mult-bounds/pull/5853) and the [entry-domain handoff](https://github.com/CrocSwap/integer-mult-bounds/pull/5852#issuecomment-6436191164). It changes verification implementation; it makes no kappa, construction, physical-cost, compiler or selected-frontier claim. Kappa research remains paused. + +## What changes + +An exact 16,384-entry per-trace contribution table avoids recomputing pure Fraction contributions. Bounded injective tokens represent complete canonical weight pairs, always indexed by the original source site i. A small C extension implements the exact seven-integer key, FIFO bookkeeping and coefficient-loop control. It uses authenticated Fraction descriptors and ordinary Python C APIs, retaining the GIL. The original Python Fraction callback computes every miss; all three score additions still use Python numeric operations in their original order. Per-coefficient F(0) construction is deliberately retained. + +Rows, rounded injections, ideal metadata, full output comparisons, signed witnesses, peaks, hashes, reverse checks and the independent exact integer backend remain active. Mutable caches and answers never cross traces or backends. Only loaded immutable native code is reused within one fresh process; each fresh process pays its build. Unsupported or changed native packets use the inherited checked path or literal original trace under the documented domain rules. A platform without the required compiler/headers fails native qualification explicitly. + +## Frozen sources and coverage + +Canonical main: `de5ec2e7a6074068452f45b1a191b5c72832df4a`, priority 8. Complete PR5848: `66fb6c6b8683b37967e9d7f313b3df99a49d2406`. Its 97-file official export remains byte-for-byte unchanged. The source manifest pins all 12 retained inputs to own ancestor `2ebc3a071c62fc839aaed1291220d78a317395d4`. The separate inherited test-only PR5761 repair retains its exact author/commit credit; no shared test is weakened here. + +- **964** complete finite comparisons on 241 programs at four capacities, with full values, numeric types and input preservation. +- **73** inherited controls and **45** native controls, covering collision equality, FIFO wrap, exceptions, source/runtime drift, fallback, metadata ownership, cyclic GC, re-entry and malformed C API packets. +- **Four** unchanged predecessor source-custody rejection checks in registered verification, separate from both timed candidate.py stages as in PR5848. +- Complete independent qualification on **25,984 events / 799 coordinates**, including all 120 inherited independent finite fixtures, six source controls, full actual ideal/error outputs and witness comparisons. Actual output SHA256: `954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9`. +- Complete optimized qualification also passes. The C native actual path preserves 2,579,750 calls, 2,252,966 hits, 326,784 misses, 310,400 FIFO evictions and 3,587 weight tokens. + +The native API accepts validated packets from the source-bound wrapper. Its error/lifetime checks are memory-safety defenses, not a theorem that arbitrary callbacks or noninjective supplied tokens have Fraction semantics. The proof assumes stable inputs/runtime during a trace, matching the predecessor. Full-C-API support is the tested CPython 3.12 ABI; this is not abi3, subinterpreter or free-threaded support. + +## Reproduction + +Tested on Linux x86_64, CPython 3.12.3 and GCC 13.3. An existing `cc` and Python 3.12 development headers are required; no dependencies are installed and no compiled binary is committed. + +Registered finite/native/source verification, about three seconds here: + +```sh +python3 -B scripts/research_package.py --package research/fraction-native-qualification +``` + +Explicit complete guarded replay, about 33 seconds here. Choose a new evidence directory outside the package; it retains stdout, stderr, timing, source inventory and RSS receipts: + +```sh +python3 -B research/fraction-native-qualification/replay.py /tmp/native-qualification-evidence +``` + +Fresh complete timing round, first pair then the remaining fixed-order repetitions only if the first pair passes both 15% gates: + +```sh +python3 -B research/fraction-native-qualification/benchmark.py pair /tmp/native-qualification-benchmark +python3 -B research/fraction-native-qualification/benchmark.py remaining /tmp/native-qualification-benchmark +``` + +The same default 180-second command / 1 GiB sampled process-group RSS / 600-second initial round and 1,500-second shared-round contract applies. One serial runner, zero automatic retries. Do not infer complete performance from the inner `qualify.seconds`: it excludes the preceding native finite/build stage. The outer GNU-time receipt is authoritative and includes compiler children. The original raw timing driver and every observation are retained under `evidence/runtime`; the portable wrapper changes evidence/source path resolution only. + +## Findings, failures and limits + +The earlier table, entry gate and compact keys were correct within their tested domains but failed their complete-cost screens. Cache-only C lookups were slightly slower than the Python slot-key parent in the fixed micro screen. The full coefficient-loop mechanism subsequently passed a complete actual audit and the complete timing gate. Do not discard those negative results or credit all improvement to C alone: the candidate combines the exact table, source-bound entry/compact/slot mechanisms and native bookkeeping. + +The first debug attempt passed scientific checks but stopped on a temporary-directory cleanup ResourceWarning. Explicit cleanup fixed it without suppressing warnings. A later forced-GC constructor fixture was inert: its callback did not run during construction, so it did not demonstrate the intended interleaving. That failure and draft remain; a deterministic metadata-ownership test replaced it. Checked constructor token reads remain a source-reviewed safety condition. No empirically exercised constructor-GC interleaving is claimed. All attempts are retained; no automated retry or timing sample was dropped. + +The source reviewer is a user-requested GPT-6-astra xhigh agent and performed static review only. All compiler and numerical execution used one parent runner. This is assisted engineering verification, without independent human or proof-kernel acceptance. Registered hosted replay covers finite/native/source checks; it does not itself freshly establish the local complete-performance measurements. See [PROOF.md](PROOF.md), [VALIDATION.json](VALIDATION.json), the [complete timing gate](evidence/runtime/GATE-6.json) and the retained static reviews. + +## Open next questions + +Can a further source-bound reduction in the remaining coefficient/score bookkeeping pay its additional validation bill? First census the new candidate, refresh upstream overlap and name one bounded feasibility test. Keep this measured candidate frozen during publication. A new arithmetic implementation would require a broader independent proof and validation bill; it is outside this contribution. + +Original mathematics/arithmetic: Ali Romman and all retained P104/native/compiler/precision authors; see NOTICE and nested archives. New profiling, table/domain/compact/slot integration, C helper and validation: Chris R / Clear1nsight with substantial OpenAI Codex/Astra assistance. Apache-2.0. diff --git a/research/fraction-native-qualification/RESULT.json b/research/fraction-native-qualification/RESULT.json new file mode 100644 index 0000000000..a5ccf66db3 --- /dev/null +++ b/research/fraction-native-qualification/RESULT.json @@ -0,0 +1,154 @@ +{ + "all_coverage_preserved": true, + "inherited": { + "all_coverage_preserved": true, + "inherited": { + "all_coverage_preserved": true, + "inherited": { + "all_coverage_preserved": true, + "inherited": { + "all_complete_values_and_types_equal": true, + "cases": 241, + "controls": [ + "returned-mutation-isolated", + "source-drift", + "Fraction-type-drift", + "module-byte-drift", + "live-code-drift", + "nested-live-code-drift", + "omitted-witness", + "omitted-rounded-sites", + "wrong-coefficient", + "wrong-weighted-increment", + "bad-role", + "bad-scalar", + "missing-weight", + "restore-success", + "restore-exception", + "fresh-derivation", + "key-field-0", + "key-field-1", + "key-field-2", + "key-field-3", + "key-field-4", + "FIFO-eviction", + "canonical-key", + "hash-collision", + "disabled", + "invalid-capacity--1", + "invalid-capacity-16385", + "invalid-capacity-True", + "invalid-capacity-1.5", + "uncached-exception-0", + "uncached-exception-1", + "fresh-call-table", + "stats-mutation", + "failed-call-clears-stats" + ], + "events": 10164, + "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY" + }, + "new_control_count": 20, + "new_controls": [ + "all-241-fixtures-take-certified-domain", + "subtypes-and-foreign-types-fall-back-without-custom-methods", + "metaclass-container", + "metaclass-scalar", + "original-fallback-dict-subclass", + "original-fallback-program-subclass", + "original-fallback-event-subclass", + "original-fallback-weights-subclass", + "original-fallback-row-subclass", + "original-fallback-rounded-subclass", + "original-fallback-Fraction-subclass", + "original-fallback-integer-weights", + "original-fallback-boolean-public", + "exact-internal-type-preservation-at-certified-updates", + "malformed-outcome-missing-weight", + "malformed-outcome-bad-role", + "malformed-outcome-bad-scalar", + "malformed-outcome-short-event", + "recertification-invalidates-certified-method", + "disabled-capacity-not-certified" + ], + "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY" + }, + "new_control_count": 9, + "new_controls": [ + "canonical-full-pair-tokens", + "weight-token-hash-collision", + "bounded-context-overflow", + "event-q-canonical-equality-and-FIFO-counters", + "six-complete-trace-counter-and-type-comparisons", + "source-site-weight-ownership", + "wrong-token-alias-detected", + "overflow-fallback-preserves-original", + "fresh-token-and-cache-lifetimes" + ], + "status": "PASS_COMPACT_KEY_FINITE_ONLY" + }, + "new_control_count": 10, + "new_controls": [ + "changed-getter-invalidates", + "changed-live-getter-code", + "foreign-slot-probe-is-pure", + "changed-attribute-lookup", + "missing-attribute-handler-presence", + "binding-restored", + "slot-path-selected", + "post-derive-getter-drift-literal-fallback", + "uninitialized-unused-weight-fallback", + "foreign-slot-value-fallback" + ], + "status": "PASS_SLOT_KEY_FINITE_ONLY" + }, + "native_control_count": 45, + "native_controls": [ + "canonical-keys-FIFO-wrap-counters", + "native-hash-collision", + "exact-one-callback-per-miss", + "uncached-native-error-0", + "uncached-native-error-1", + "full-cache-failure-before-eviction", + "cache-survives-callback-exception", + "capacity-0", + "capacity--1", + "capacity-16385", + "capacity-True", + "capacity-1.5", + "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "index--1", + "index-3", + "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "index-True", + "index-0", + "arity", + "keywords", + "exact-operand", + "exact-scalar", + "event-creation", + "descriptor-protocol", + "token-length", + "token-range", + "partial-init-length", + "partial-init-weight", + "callback-result-shape", + "callback-result-type", + "callback-reentry", + "event-owns-parent", + "GC-callback-cycle", + "native-statistics-isolated", + "native-coefficient-loop", + "same-row-lowlevel-rejection", + "dict-iterator-mutation-safe", + "callback-list-mutation-safe", + "native-source-authenticated", + "callback-descriptor-is-pure", + "plain-callback-rejected", + "live-callback-code-drift", + "owned-metadata-snapshot", + "same-row-source-fallback", + "malformed-scalar-literal-fallback" + ], + "status": "PASS_NATIVE_FINITE_ONLY" +} diff --git a/research/fraction-native-qualification/SOURCES.json b/research/fraction-native-qualification/SOURCES.json new file mode 100644 index 0000000000..d8cb6e68d3 --- /dev/null +++ b/research/fraction-native-qualification/SOURCES.json @@ -0,0 +1,120 @@ +{ + "schema_version": 1, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + { + "path": "research/fraction-native-qualification/inputs/PR5848.tar", + "usage": "input", + "git_blob": "307d09d2a968e1bbec8025d9fbd0a884df790d12", + "sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/inputs/PR5848.tar" + }, + { + "path": "research/fraction-native-qualification/slot_parent.py", + "usage": "input", + "git_blob": "5a77bebfe03d308baf223e517b7bd04e52cb204c", + "sha256": "b1ee09c1dfd4e36677b57dd71124d4d30f38c7df5f460a787fde3636b91e4e24", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/slot_parent.py" + }, + { + "path": "research/fraction-native-qualification/slot_finite.py", + "usage": "input", + "git_blob": "3231246efe9a2d1b975989a1ff9e000ffb0d9976", + "sha256": "5e23174a5b37e014b154e3030b2e96e08f2aeeedc723f0273f829f68ca481390", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/slot_finite.py" + }, + { + "path": "research/fraction-native-qualification/compact_parent.py", + "usage": "input", + "git_blob": "b3dc1be5c08b32990e456260843f40bc34fde89a", + "sha256": "448fba3f199cb4e36707c86819a319d207d8d24062fb5478c06aeea98f6df61a", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/compact_parent.py" + }, + { + "path": "research/fraction-native-qualification/compact_finite.py", + "usage": "input", + "git_blob": "b6cc3d9ddb1a266c8f1933c55e746e14be404d5b", + "sha256": "9a9ba69920c5b2b880869b0a72eb5fab43be21d79efd8e4152dd886ecfd859d1", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/compact_finite.py" + }, + { + "path": "research/fraction-native-qualification/entry_parent.py", + "usage": "input", + "git_blob": "2a631bdc4cda602159a47b5f5b5b1d70972acd56", + "sha256": "cf83523a35acdea39cbe48cf04a775ab9d00f673525108e71a5dc6005650a7fe", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/entry_parent.py" + }, + { + "path": "research/fraction-native-qualification/entry_finite.py", + "usage": "input", + "git_blob": "cafaf408fd4e3ec6cdc42044c8d4187c51f55dde", + "sha256": "ff7c8d70bdd1b4d265536484c8a8e801154beb38bf14c914aba5137a64dfded9", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/entry_finite.py" + }, + { + "path": "research/fraction-native-qualification/table_parent.py", + "usage": "input", + "git_blob": "7f44b25859e90d981587a53e9467284961f60a8f", + "sha256": "d598b8a757251c1e38ed77af6cc2aebe1b8ae23ad29ce06bff3ca973eb56dbc4", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/table_parent.py" + }, + { + "path": "research/fraction-native-qualification/parent_finite.py", + "usage": "input", + "git_blob": "e00dd293859b115cad99644e1c614a13c71fc133", + "sha256": "b2df739750829d7bf1a6446ea79d02a65641d7a85ead56d7ad941069bb146e4f", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/parent_finite.py" + }, + { + "path": "research/fraction-native-qualification/frozen.py", + "usage": "input", + "git_blob": "eb26be4a0f2e27e03becd3741da98f65799b8f0a", + "sha256": "a5848c4290e96fc639bd15beb3d533e49fa026e9e0333381543acdb0bf1a9547", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/frozen.py" + }, + { + "path": "research/fraction-native-qualification/slot_binding.py", + "usage": "input", + "git_blob": "e226fd730ed33f6ac769240f6530325c8db470e0", + "sha256": "f2f3193461b9f705a2683107c2305c40d2f82d9f1087a2af25cf9e88f45fc593", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/slot_binding.py" + }, + { + "path": "research/fraction-native-qualification/GETTER-SHAPES.json", + "usage": "input", + "git_blob": "d3dadac22725126c3283d99f85073a1b7c8c8c83", + "sha256": "0ca61c0d9062b93d16957357f2190b702a99be0104d980abeba4ae20a81eaed4", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/GETTER-SHAPES.json" + } + ], + "external_origin": { + "pr": 5848, + "head": "66fb6c6b8683b37967e9d7f313b3df99a49d2406", + "archive_sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6", + "files": 97 + }, + "predecessors": { + "table_pr": 5852, + "zero_unit_pr": 5853, + "entry_artifact": "070e377470a0778d466eabb0fcfcba600c707d19", + "slot_and_compact": "Own source-bound feasibility predecessors, retained in this own input ancestor; unpublished earlier local micro/actual evidence is labelled." + }, + "runtime": { + "platform": "Linux x86_64 CPython3.12.3 GCC13.3", + "Fraction_file_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "native_source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "full_C_API": "CPython3.12 ABI; not abi3" + } +} diff --git a/research/fraction-native-qualification/TASK.json b/research/fraction-native-qualification/TASK.json new file mode 100644 index 0000000000..f7b568ff15 --- /dev/null +++ b/research/fraction-native-qualification/TASK.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "task_id": "replay-runtime", + "original_card": { + "id": "replay-runtime", + "question": "Can one measured replay bottleneck be sped up without dropping coverage?", + "starting_points": [ + "scripts/run_isolated_tests.py", + "scripts/verify_replay_coverage.py", + "certificates/selected-result.json" + ], + "methods": [ + "Profile one isolated replay and optimize the measured bottleneck.", + "Design source-bound reuse with explicit dependency invalidation and negative controls." + ], + "acceptance_gate": "Report before/after wall time on the same fixture, retained checks and invalidation behavior.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Measure one unchanged fixture, preserve check coverage, and test one optimization with invalidation controls.", + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "allowed_variations": [ + "Profile one stage or design one source-bound cache boundary." + ], + "scope_change_triggers": [ + "Skipping coverage or comparing different fixtures to claim speedup." + ], + "overlap_terms": [ + "replay runtime", + "cache invalidation", + "isolated tests" + ] + }, + "scope_status": "refined", + "scope_change_reason": "Donor requested C and at least15% complete wall AND CPU savings. Finite/native gate, actual audit and complete cold-build BCCBBC gate passed.", + "actual_scope": "PR5848/frozen66fb6c6/native-cache-complete-qualification", + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "stop_rule": "Publish verified measured scope, then reassess before further optimization. Preserve coverage, cold build and180s/1GiB/600sinitial1500shared/serial/no-auto-retry contract.", + "time_budget_minutes": 60, + "outcome": "completed", + "evidence": "PROOF.md, RESULT.json and evidence/runtime/GATE-6.json; full normal/O and source custody; publication controls separate.", + "author": "Chris R / Clear1nsight", + "ai_assistance": "Substantial OpenAI Codex implementation and user-requested GPT-6-astra xhigh static API/source review. One parent numerical runner; no independent human or proof-kernel acceptance.", + "open_questions": [ + { + "question": "Can one further source-bound native bookkeeping reduction pay its additional verification bill?", + "why_it_matters": "The minimum15% complete gate passes, but the user requests further justified improvements.", + "first_step": "Profile/census the new candidate, freeze one costed feasibility nomination, refresh overlap and run the smallest discriminating test before construction.", + "blocked_by": "Do not change this measured candidate or its scientific coverage during publication." + } + ], + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a" +} diff --git a/research/fraction-native-qualification/VALIDATION.json b/research/fraction-native-qualification/VALIDATION.json new file mode 100644 index 0000000000..f8d372ac05 --- /dev/null +++ b/research/fraction-native-qualification/VALIDATION.json @@ -0,0 +1,72 @@ +{ + "local_only": true, + "complete_BCCBBC": { + "medians": { + "B": { + "wall": 40.51615557898185, + "cpu": 40.33 + }, + "C": { + "wall": 32.771296680002706, + "cpu": 32.74 + } + }, + "saving": { + "wall": 0.19115483165428626, + "cpu": 0.18819737168361017 + }, + "order": [ + "B1", + "C1", + "C2", + "B2", + "B3", + "C3" + ], + "all_full_receipts_equal": true, + "cold_compile_included": true + }, + "complete_optimized": { + "exit": 0, + "label": "full-native-O", + "optimized": true, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 116686848, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14103, + "stdout_sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 112500, + "system_seconds": 0.18, + "user_seconds": 32.33 + }, + "wall_seconds": 32.580494505004026 + }, + "finite_comparisons": 964, + "inherited_controls": 73, + "native_controls": 45, + "predecessor_custody_controls": 4, + "all_complete_values_and_types_and_witnesses_preserved": true, + "actual_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "guarded_attempts": 20, + "guarded_wall_seconds": 332.434005899966, + "retained_failed_attempts": [ + "finite-native-debug", + "finite-native-packet-O" + ], + "automatic_retries": 0, + "independent_human_or_kernel_acceptance": false, + "hosted_performance": false, + "scope": "Only frozen PR5848; no kappa, physical/cost/compiler or selected-frontier change. Four predecessor custody controls are separate registered checks, as in PR5848, and excluded from both timed candidate.py stages.", + "packaged_registered_finite_normal_and_optimized": "PASS, including all four unchanged custody controls; receipts in evidence/runtime/runs" +} diff --git a/research/fraction-native-qualification/VERIFY.json b/research/fraction-native-qualification/VERIFY.json new file mode 100644 index 0000000000..b1458cfac7 --- /dev/null +++ b/research/fraction-native-qualification/VERIFY.json @@ -0,0 +1,31 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/fraction-native-qualification/inputs/PR5848.tar", + "research/fraction-native-qualification/slot_parent.py", + "research/fraction-native-qualification/slot_finite.py", + "research/fraction-native-qualification/compact_parent.py", + "research/fraction-native-qualification/compact_finite.py", + "research/fraction-native-qualification/entry_parent.py", + "research/fraction-native-qualification/entry_finite.py", + "research/fraction-native-qualification/table_parent.py", + "research/fraction-native-qualification/parent_finite.py", + "research/fraction-native-qualification/frozen.py", + "research/fraction-native-qualification/slot_binding.py", + "research/fraction-native-qualification/GETTER-SHAPES.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Fresh964 complete comparisons,73 inherited+45 native controls and all4 unchanged custody controls. Cold C build requires existing cc/Python3.12 headers; no dependency installation. Finite/source/native coverage only; full replay and performance remain separate opt-in evidence." + } + ] +} diff --git a/research/fraction-native-qualification/actual_audit.py b/research/fraction-native-qualification/actual_audit.py new file mode 100644 index 0000000000..1b50e726b0 --- /dev/null +++ b/research/fraction-native-qualification/actual_audit.py @@ -0,0 +1,32 @@ +"""One complete frozen original/slot/native audit; compiler work charged.""" +import gzip,importlib.util,json,sys,time,resource +from frozen import baseline,require +from compact_finite import types_of +from fraction_table import derive +import slot_parent,native_backend + +with baseline() as package: + sys.path.insert(0,str(package)) + spec=importlib.util.spec_from_file_location('native_actual_bundle',package/'source.py') + source=importlib.util.module_from_spec(spec);spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('native_actual_source',p/'verify.py') + v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (original_path,original,reference): + word=json.loads(gzip.decompress((original_path/'inputs/WORD.json.gz').read_bytes())) + ideal,weights=reference.ideal(word);rounded=set(ideal['counts']) + fingerprint=reference.digest((word,weights,sorted(rounded))) + parent=slot_parent.derive(reference);native=derive(reference) + observed=[];base=None + for label,fn in [('original',reference.error_trace),('slot-parent',parent),('native-apply-cold',native)]: + start_children=resource.getrusage(resource.RUSAGE_CHILDREN) + cpu=time.process_time();wall=time.perf_counter();result=fn(word,weights,rounded);elapsed=time.perf_counter()-wall;used=time.process_time()-cpu + end_children=resource.getrusage(resource.RUSAGE_CHILDREN) + child_cpu=end_children.ru_utime+end_children.ru_stime-start_children.ru_utime-start_children.ru_stime + if base is None:base=result + else:require(result==base and types_of(result)==types_of(base),'all actual values/types/witnesses') + require(reference.digest((word,weights,sorted(rounded)))==fingerprint,'all actual inputs unchanged') + observed.append(dict(label=label,wall_seconds=elapsed,cpu_seconds=used+child_cpu,parent_cpu_seconds=used,compiler_child_cpu_seconds=child_cpu,full_output_sha256=reference.digest(result))) + require(native.compacted_selected() is True,'actual native path used') + require(parent.statistics()==native.statistics(),'all actual cache statistics unchanged') + print(json.dumps(dict(status='PASS_FULL_NATIVE_ACTUAL_AUDIT',events=len(word['program']),coordinates=ideal['n'],observations=observed,all_values_types_witnesses_inputs_equal=True,table_statistics=native.statistics(),weight_tokens=native.token_count(),build=native_backend.receipt(),direct_add=False,not_complete_performance=True),sort_keys=True)) diff --git a/research/fraction-native-qualification/benchmark.py b/research/fraction-native-qualification/benchmark.py new file mode 100644 index 0000000000..092f972e3d --- /dev/null +++ b/research/fraction-native-qualification/benchmark.py @@ -0,0 +1,46 @@ +"""Fresh cold BCCBBC; full original and every new finite/native check billed.""" +import json,statistics,sys +from pathlib import Path +import guard +if len(sys.argv)!=3:raise ValueError('pair|remaining and an external evidence directory') +PACKAGE=Path(__file__).resolve().parent +guard.HERE=Path(sys.argv[2]).resolve() +if guard.HERE.is_relative_to(PACKAGE):raise ValueError('Evidence directory must be outside the immutable package') +guard.HERE.mkdir(parents=True,exist_ok=True) +guard.SOURCE=PACKAGE +guard.CLOSURE=tuple(sorted(str(p.relative_to(guard.SOURCE)) for p in guard.SOURCE.rglob('*') if p.is_file() and '__pycache__' not in p.parts))+('/usr/lib/python3.12/fractions.py',) +guard.AGGREGATE=600 +sys.path.insert(0,str(guard.SOURCE)) +from frozen import payload,require +EXPECTED=json.loads(payload()['research/p104-single-pass-qualification/RESULT.json']) +ORDER=[('B1','full_B.py'),('C1','full_C.py'),('C2','full_C.py'),('B2','full_B.py'),('B3','full_B.py'),('C3','full_C.py')] + +def receipt(label): + p=guard.HERE/'runs'/label + r=json.loads((p/'receipt.json').read_text());require(r['status']=='PASS','full bounded command '+label) + out=json.loads((p/'stdout.txt').read_text().splitlines()[-1]);require(out['mode']=='qualify' and out['receipt']==EXPECTED,'unchanged full scientific receipt '+label) + if label.startswith('C'): + rows=[json.loads(x) for x in (p/'stdout.txt').read_text().splitlines() if x.startswith('{')] + require(sum(x.get('status')=='PASS_COMPLETE_NATIVE_COVERAGE' for x in rows)==1,'native and compiler coverage '+label) + return r + +def gate(labels): + groups={arm:[receipt(label) for label in labels if label.startswith(arm)] for arm in 'BC'} + medians={arm:dict(wall=statistics.median(x['wall_seconds'] for x in rows),cpu=statistics.median(x['usage']['user_seconds']+x['usage']['system_seconds'] for x in rows)) for arm,rows in groups.items()} + saving={k:1-medians['C'][k]/medians['B'][k] for k in ('wall','cpu')} + result=dict(medians=medians,saving=saving,order=labels,all_full_receipts_equal=True,cold_compile_included=True) + (guard.HERE/('GATE-'+str(len(labels))+'.json')).write_text(json.dumps(result,indent=2)+'\n') + require(min(saving.values())>=.15,'15% complete wall AND CPU gate') + return result + +require(len(sys.argv)==3 and sys.argv[1] in ('pair','remaining'),'pair or remaining') +with (guard.HERE/'execution.lock').open('a') as lock: + guard.fcntl.flock(lock,guard.fcntl.LOCK_EX|guard.fcntl.LOCK_NB) + if sys.argv[1]=='pair': + for label,script in ORDER[:2]:guard.run(label,script);receipt(label) + result=gate(['B1','C1']) + else: + gate(['B1','C1']) + for label,script in ORDER[2:]:guard.run(label,script);receipt(label) + result=gate([x[0] for x in ORDER]) + print(json.dumps(result,sort_keys=True)) diff --git a/research/fraction-native-qualification/custody.py b/research/fraction-native-qualification/custody.py new file mode 100644 index 0000000000..4bd2b4592c --- /dev/null +++ b/research/fraction-native-qualification/custody.py @@ -0,0 +1,19 @@ +"""Retain all four unchanged predecessor custody checks, with scoped imports.""" +import importlib.util,sys +from frozen import baseline + +def main(): + prior={name:sys.modules.pop(name,None) for name in ('source','observe')} + paths=list(sys.path) + try: + with baseline() as package: + sys.path.insert(0,str(package)) + spec=importlib.util.spec_from_file_location('native_predecessor_custody',package/'custody.py') + module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module);module.main() + finally: + sys.path[:]=paths + for name,value in prior.items(): + sys.modules.pop(name,None) + if value is not None:sys.modules[name]=value + +if __name__=='__main__':main() diff --git a/research/fraction-native-qualification/evidence/FINITE-INERT-GC-FIXTURE.py.txt b/research/fraction-native-qualification/evidence/FINITE-INERT-GC-FIXTURE.py.txt new file mode 100644 index 0000000000..e91610348f --- /dev/null +++ b/research/fraction-native-qualification/evidence/FINITE-INERT-GC-FIXTURE.py.txt @@ -0,0 +1,13 @@ + ws=[(F(1),F(1))]*256;ts=list(range(256));fired=[];thresholds=gc.get_threshold();gc.collect() + def on_gc(phase,info): + if phase=='start' and ts:ts.clear();fired.append(True) + gc.callbacks.append(on_gc) + try: + gc.set_threshold(1,1,1) + try:make(ws=ws,ts=ts) + except (IndexError,ValueError):pass + else:raise ValueError('constructor mutation was not rejected') + finally: + gc.callbacks.remove(on_gc);gc.set_threshold(*thresholds) + require(fired,'constructor GC mutation fixture exercised') + controls.append('GC-mutated-token-packet-safe') diff --git a/research/fraction-native-qualification/evidence/HARNESS-CORRECTION.json b/research/fraction-native-qualification/evidence/HARNESS-CORRECTION.json new file mode 100644 index 0000000000..8179a6f905 --- /dev/null +++ b/research/fraction-native-qualification/evidence/HARNESS-CORRECTION.json @@ -0,0 +1,13 @@ +{ + "preserved_attempt": "runtime/runs/finite-native-debug", + "outcome": "All scientific/native checks and exit 0; runner correctly STOPPED for ResourceWarning on implicit TemporaryDirectory cleanup.", + "manual_correction": "Register explicit owned compilation-directory cleanup with atexit; do not suppress warnings or change coverage. Native API and C source unchanged.", + "source_refinement": "Before actual audit, native entry additionally sends malformed exact-Fraction scalar slots to literal-original fallback.", + "automatic_retries": 0, + "inert_GC_fixture": { + "attempt": "runtime/runs/finite-native-packet-O", + "preserved_draft": "FINITE-INERT-GC-FIXTURE.py.txt", + "failure": "The forced-threshold GC callback did not run inside the constructor, so the demanded rejection did not occur. Not a demonstrated native bug.", + "manual_correction": "Retain the failed attempt. Replace the timing-dependent fixture with deterministic owned metadata mutation/lifetime coverage. Checked token reads remain a source-reviewed safety requirement; do not claim a constructor-GC interleaving was empirically exercised." + } +} diff --git a/research/fraction-native-qualification/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md b/research/fraction-native-qualification/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md new file mode 100644 index 0000000000..5cc8c57baf --- /dev/null +++ b/research/fraction-native-qualification/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md @@ -0,0 +1,65 @@ +# Native cache/context helper: preconstruction review + +**Recommendation: proceed to a bounded native-helper feasibility gate, with Fraction arithmetic and the Python trace unchanged.** Prefer a vectorcall Event and authenticated member-descriptor reads over repeated `PyObject_GetAttrString`. The target is Python key/context/cache bookkeeping, not a second rational engine. This review approves neither an unseen implementation nor a performance claim. No compiler, arithmetic experiment, native module or replay was run by this reviewer. Only local headers and primary CPython documentation/source were inspected. + +The user explicitly requested C. Parent owns implementation and the only scientific runner. Keep kappa work, other feeds and publication paused. The supported environment is the actual CPython 3.12 ABI and compiler used for the cold build; do not describe a full-C-API extension as `abi3` merely because some individual calls belong to the Stable ABI. + +## Recommended API boundary + +- Cache is fresh for each trace and owns the exact Python miss callback, immutable snapshots of the weight/token metadata, authenticated Fraction descriptors/type, dictionary and fixed-capacity FIFO ring. Snapshotting means copying the metadata structure into owned tuples, not merely retaining the original mutable list. Standard Fraction objects remain under the predecessor's stable/immutable-value premise. +- Event owns a strong Cache reference and captures q plus its two canonical key components. Its three positional inputs are old, v and source-site i. Cache should not retain every Event; avoid a reverse Event ownership cycle or an event-history list. Direct score addition stays disabled for the first native nomination. +- Enable vectorcall on the Event type, store its function pointer at the declared offset, extract positional count with `PyVectorcall_NARGS`, reject unsupported keywords/arity, and give `tp_call` identical behavior through `PyVectorcall_Call`. Do not misuse the arguments-offset flag. Call the Python miss callback with `PyObject_Vectorcall` and five arguments. Keep the GIL throughout. [Python 3.12 call protocol](https://docs.python.org/3.12/c-api/call.html). +- A certified exact member descriptor may be read through `Py_TYPE(descriptor)->tp_descr_get(descriptor, operand, (PyObject *)fraction_type)`. Retain descriptor ownership and check a non-null function pointer. This uses the descriptor protocol rather than a Fraction-layout cast. Preserve the preceding property/slot/getattribute binding and per-trace freshness checks, because bypassing a changed public getter would change semantics. The documented slot has the three-object descriptor-get signature. [Type slot reference](https://docs.python.org/3.12/c-api/typeobj.html#c.PyTypeObject.tp_descr_get). + +The CPython 3.12 member-descriptor implementation performs its owner/type check and delegates to `PyMember_GetOne`; its object-valued member path returns a strong reference. Accordingly, each successful integer slot read must either transfer its reference into the new key tuple or be decremented on every exit path. These source links explain the API behavior; they are reference material, not substitutes for the installed-runtime/ABI binding. [Descriptor implementation](https://github.com/python/cpython/blob/3.12/Objects/descrobject.c), [member implementation](https://github.com/python/cpython/blob/3.12/Python/structmember.c). + +## Ownership rules that must be explicit in the C review + +| Item | Required ownership | +| --- | --- | +| Cache metadata, callback, descriptor and type fields | Owned references, released on clear/deallocation | +| Event Cache/q/q-numerator/q-denominator | Owned references; an Event remains safe if the caller drops its Cache variable | +| Fresh seven-element key | One local owned reference until insertion/return cleanup | +| Each FIFO ring entry | Its own owned key reference, independently of dictionary ownership | +| Dictionary hit | Borrowed from `PyDict_GetItemWithError`; return a new reference | +| Successful Python miss result | New reference; dictionary insertion retains its own reference, and the caller receives an owned reference | + +Use `PyDict_GetItemWithError`, distinguishing a missing key from a pending exception. Ordinary `PyDict_GetItem` can suppress hash/equality errors. `PyDict_SetItem` does not steal its value reference. Check every dictionary API return value. [Dictionary API](https://docs.python.org/3.12/c-api/dict.html). + +Fill only newly allocated tuples with `PyTuple_SET_ITEM`, whose reference transfer must be accounted for. Never use unchecked tuple item/size macros before establishing exact container shape and index bounds. Any borrowed metadata object remains valid only while its owning container is retained. [Tuple API](https://docs.python.org/3.12/c-api/tuple.html). + +Decrementing a reference can run Python finalization. Restore internal invariants before releasing old objects, clear pointers before decref, and make partial-construction cleanup safe. Do not infer ownership from apparent reference counts or immortal integers. [Reference-counting API](https://docs.python.org/3.12/c-api/refcounting.html). + +## FIFO and exception contract + +Preserve the exact seven-component key order and Python integer objects. Do not narrow numerators/denominators to C integers, use raw hashes as identities, or change collision resolution. Hits return the existing result and do not move the FIFO position. A miss first invokes the unchanged Python computation; a computation failure must not evict or cache anything. Successful full-cache misses evict the oldest entry before inserting the new one, matching the parent order. + +Maintain explicit `head`, resident `count` and fixed ring capacity. On successful eviction, remove the corresponding dictionary key and ring reference together and update the head/count consistently. If the later insertion fails, leave a consistent smaller cache and propagate the exception; do not leave a ring entry for a dictionary insertion that never succeeded. Do not temporarily exceed the capacity to simplify rollback. Counters should follow the parent's successful and exceptional transitions, and C counters must not invoke signed-overflow undefined behavior. + +Calling Python on a miss creates a reentrancy boundary. The known compute function is pure in the supported runtime, but native objects should not become memory-unsafe if an injected callback reenters them. Prefer a small busy/closed guard and reject reentrant mutation; alternatively document and enforce a callback restriction sufficient to prove non-reentrancy. Preserve the original callback exception and return `NULL`; do not convert it to a miss, cache a failure, retry, or continue with a pending error. Cover recursive callback handling and reset the guard on every failure path. + +The optimization domain must establish valid internal i/metadata bounds before unchecked access. Inherited malformed-word/missing-weight cases must select original behavior or preserve its exception type/message/order. A stronger pure entry condition such as sufficient metadata length may safely select original fallback; it must not reject an input the original accepts. Separately, direct calls to the exposed C API with invalid types, huge/negative indices or malformed descriptors must raise Python exceptions, never read invalid memory. + +## Native object lifecycle + +Cache and Event contain references to Python containers/callables. Support cyclic GC with complete traversal of owned references and an appropriate clear/deallocation path, unless a strictly enforced acyclic graph is actually proved. Callback closures can otherwise create cycles even if Cache does not own Events. Initialize all owned pointers before tracking; untrack before clearing/deallocation, and pair the allocation/free APIs correctly. [Cyclic-GC requirements](https://docs.python.org/3.12/c-api/gcsupport.html). + +Prefer non-subclassable types with no writable native fields. Prevent public creation or reinitialization of uninitialized Event/Cache instances, or require an initialized-state check on every entry. A cleared or partially constructed instance must not dereference null fields. Heap-type deallocation must also handle its type reference correctly. Keep mutable cache data out of module globals; only authenticated loaded code/types may be reused in a process. Do not claim subinterpreter or free-threaded support without a separate design. + +## Smallest meaningful coverage gate + +Retain all prior finite comparisons and controls, including the compact-key/slot binding gates actually used by this candidate. Add focused native checks for: + +1. Capacities 0/1/2/full, FIFO wraparound, equal-value keys, deliberate integer-hash collision, unchanged token identity and fresh traces/Events. +2. Identical outputs/counters and Python callback invocation count: exactly one call per successful miss, none on a hit, and no cached exception. +3. Invalid arity/keywords/type/index/descriptor and partial-construction rejection, Event surviving deletion of the caller's Cache reference, and bounded create/drop/GC lifetime behavior. +4. Callback failure/reentrancy, cleanup after failure, full-cache failure ordering, output/statistics isolation, and unsupported/stale binding selecting original execution. +5. One bounded finite subprocess with CPython's debug allocator/development checks, plus source review of every allocation/error/deallocation branch. This is memory-safety validation for new native ownership; it is not a replacement for scientific comparisons. + +Only then perform the parent's fixed native/Python cache micro screen. A promising result permits one original/parent/native actual audit with unchanged complete output/type/witness digests and exact calls/hits/misses/evictions/tokens. No complete qualifier is justified by micro timings alone. + +## Cold-build and acceptance accounting + +Compile and load inside every fresh complete candidate process, in a fresh owned temporary directory, without installing anything system-wide. Record C source hash, compiler/version/flags, interpreter version/SOABI/extension suffix and build/load outcome. Preserve build failures and unsupported environments; do not silently claim native coverage through fallback. A loaded immutable module may be reused within that one complete process, but every trace still gets fresh mutable Cache/Event state. + +The complete wall and CPU bill includes compilation, linking, loading, binding, all finite/native controls, metadata preparation and the scientific trace. `time.process_time()` alone excludes compiler/linker child CPU; use the existing process-group/resource accounting that includes children. Ensure a feasibility model does not either omit the build or double-count the same within-process build. A fresh complete B/C comparison remains the authority for the user's at-least-15% wall **and** CPU threshold. The C design creates a new plausible cost target, not an admitted saving. diff --git a/research/fraction-native-qualification/evidence/NATIVE-CACHE-REVIEW-SOURCES.json b/research/fraction-native-qualification/evidence/NATIVE-CACHE-REVIEW-SOURCES.json new file mode 100644 index 0000000000..81b07807b0 --- /dev/null +++ b/research/fraction-native-qualification/evidence/NATIVE-CACHE-REVIEW-SOURCES.json @@ -0,0 +1,28 @@ +{ + "scope": "Static native-helper API/refcount/FIFO feasibility review only; no compiler, native import, arithmetic or replay run", + "target": "CPython 3.12 full C API; exact ABI and build to be recorded by parent", + "preferred": "Vectorcall Event plus authenticated member-descriptor tp_descr_get; Python Fraction callback on misses", + "performance_admission": false, + "numerical_runs": 0, + "compiler_runs": 0, + "local_headers_read": [ + "/usr/include/python3.12/abstract.h", + "/usr/include/python3.12/cpython/abstract.h", + "/usr/include/python3.12/cpython/object.h", + "/usr/include/python3.12/dictobject.h", + "/usr/include/python3.12/objimpl.h", + "/usr/include/python3.12/object.h" + ], + "primary_references": [ + "https://docs.python.org/3.12/c-api/call.html", + "https://docs.python.org/3.12/c-api/dict.html", + "https://docs.python.org/3.12/c-api/typeobj.html", + "https://docs.python.org/3.12/c-api/structures.html", + "https://docs.python.org/3.12/c-api/gcsupport.html", + "https://docs.python.org/3.12/c-api/refcounting.html", + "https://docs.python.org/3.12/c-api/tuple.html", + "https://github.com/python/cpython/blob/3.12/Objects/descrobject.c", + "https://github.com/python/cpython/blob/3.12/Python/structmember.c" + ], + "source_limit": "Documentation and 3.12 branch source explain API contracts; they are not a source pin for the installed CPython binary." +} diff --git a/research/fraction-native-qualification/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md b/research/fraction-native-qualification/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md new file mode 100644 index 0000000000..c57106eccd --- /dev/null +++ b/research/fraction-native-qualification/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md @@ -0,0 +1,51 @@ +# Native full-qualification seam: final static review + +**No remaining concrete blocker was found in the requested static scope after the boundary repairs below.** The repaired native implementation may proceed to the parent's fresh complete cold B/C gate. This is a source review, not an independent execution, memory-safety proof for arbitrary Python callbacks, or performance admission. + +Reviewed C source: `78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb`. +Reviewed `full.py`: `ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0`. +Reviewed `fraction_table.py`: `d70f8095002ffedb06fd6851e5b6d127e2f24c3ad31404130216345416159cf4`. + +## Boundary repairs confirmed + +- Cache construction now fetches each token with checked `PySequence_GetItem`, owns that result, releases it on rejected type/range, and transfers it into the immutable snapshot tuple on success. The earlier unchecked caller-list access is gone. +- Contribution member reads now check each result immediately; scalar Event initialization stops immediately if the numerator getter fails before reading the denominator. +- `checked_compute` resolves raw Contributions MRO dictionaries through `type.__getattribute__`, requires an exact staticmethod and exact FunctionType, then checks code shape, defaults/closure and effective captured builtin abs. Qualification no longer invokes an arbitrary compute descriptor or treats a plain method as equivalent. +- The native loader compiles a read-only snapshot of authenticated bytes and rejects cached-module/source-digest disagreement. + +Parent reports a failed attempt to force constructor GC interleaving: its callback did not run inside the constructor. That attempt and draft remain preserved. The replacement deterministic ownership test supports metadata lifetime behavior; it does **not** empirically exercise the previously hypothesized GC interleaving. The checked item-read source fix removes the unchecked access without that empirical claim. + +## Complete seam inspection + +The outer authenticated PR5848 export supplies `candidate.py`. `full.py` requires exactly one literal Observation seam and adds the native error-trace wrapper only for the original `noisy_precision` module at that seam. The existing Observation wrapper still surrounds it. + +The following remain in the frozen candidate code and are not replaced: + +- The separately loaded integer Engine and its Observation. +- The independently loaded reference module used by the original 120-program differential and integer guards. +- Full expected contract-result equality, six source semantic controls, reverse-all/cut and literal checks performed by the original contract. +- Complete ideal/weight and actual trace/witness comparisons between the retained observations. +- Original observation lifecycle/error/alias controls in `candidate.main` and the exact frozen final receipt comparison. + +The C branch first executes the full native finite entry, including its inherited gates and cold build, then invokes the original candidate main with that single seam changed. The native actual wrapper checks route selection, exact table counters and the complete output digest. Its capture predicate uses program length; that identifies the sole call only because this exact frozen `calculate` invokes that module's `error_trace` once. Do not generalize the predicate into a general-purpose actual-word classifier. A direct complete word equality assertion would be clearer if this wrapper is later generalized. + +The stale-module cleanup is limited to `source` and `observe` modules whose files belong to expired owned temporary exports. The fresh package is then placed first on the import path. No accepted numeric result is reused; only already loaded native code is reused within the one C process. Cache/Event state remains per trace. + +## Measurement and claim boundary + +The complete benchmark must use **outer command wall and total user/system CPU including children**. The returned/printed `qualify` seconds exclude the preceding native finite suite and its build, so they cannot decide the threshold. Each fresh C process must pay its own compile/link/load cost. + +The predecessor's four custody controls are a separate registered-verification obligation outside its declared qualification benchmark. They must remain in the final registered verification; this seam review does not silently count them as executed by `full.py`. + +Parent subsequently reports the completed fresh-process B,C,C,B,B,C measurements: + +| Complete qualification median | Baseline | Native candidate | Saving | +| --- | ---: | ---: | ---: | +| Wall seconds | 40.516155579 | 32.771296680 | 19.1155% | +| Total CPU seconds | 40.33 | 32.74 | 18.8197% | + +All complete scientific receipts, native counters and full output digests reportedly agree. Parent also reports a complete optimized run passing at 32.5805 wall / 32.51 CPU seconds. These are parent-run local measurements, not executions independently repeated by this static reviewer. They supersede the earlier feasibility model as the parent's evidence for clearing the mandatory 15% threshold in both metrics. They are not a hosted-CI performance claim or a guarantee for another interpreter, compiler or machine. + +The final package should retain registered finite/native checks, the cold compilation path and four inherited custody controls, with the expensive full replay explicitly opt-in as planned. Preserve exact sources, complete timing receipts, earlier failures and negative micro findings. All implementation blockers identified in this review are resolved in the reviewed source. Further optimization, including any C arithmetic port, requires a separate bounded round after publication; no such round was started here. + +No compiler, native import, numerical test, replay or external publication was performed by this reviewer. This addendum supersedes the three outstanding implementation items in `NATIVE-CACHE-CODE-REVIEW.md`; its raw-packet/stable-runtime and coverage boundaries remain applicable. diff --git a/research/fraction-native-qualification/evidence/NATIVE-REVIEW-FINAL-STATE.json b/research/fraction-native-qualification/evidence/NATIVE-REVIEW-FINAL-STATE.json new file mode 100644 index 0000000000..aaa43f4292 --- /dev/null +++ b/research/fraction-native-qualification/evidence/NATIVE-REVIEW-FINAL-STATE.json @@ -0,0 +1,33 @@ +{ + "status": "STATIC_REVIEW_COMPLETE_NO_REMAINING_CONCRETE_BLOCKER_IN_REVIEWED_SCOPE", + "c_source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "full_source_sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "runtime_boundary": "Frozen source, qualified callback/packet and stable supported CPython runtime; not arbitrary raw callback semantics", + "actual_capture_boundary": "Program length identifies the sole actual error_trace call only in this frozen calculate source", + "parent_reported_complete_medians": { + "order": [ + "B", + "C", + "C", + "B", + "B", + "C" + ], + "baseline_wall": 40.516155579, + "baseline_cpu": 40.33, + "candidate_wall": 32.77129668, + "candidate_cpu": 32.74, + "wall_saving_percent": 19.1155, + "cpu_saving_percent": 18.8197 + }, + "parent_reported_complete_optimized": { + "wall": 32.5805, + "cpu": 32.51, + "status": "PASS" + }, + "scientific_runs_by_reviewer": 0, + "compiler_runs_by_reviewer": 0, + "external_posts_by_reviewer": 0, + "hosted_performance_claim": false, + "next": "Parent publication packaging only; any further optimization requires a separate bounded round after publication." +} diff --git a/research/fraction-native-qualification/evidence/PLAN.json b/research/fraction-native-qualification/evidence/PLAN.json new file mode 100644 index 0000000000..0f5d3eb42d --- /dev/null +++ b/research/fraction-native-qualification/evidence/PLAN.json @@ -0,0 +1,22 @@ +{ + "mechanism": "C cache/context and optional coefficient-loop apply using existing Fraction miss callback and PyNumber_InPlaceAdd; unchanged outer scientifictrace", + "source_PR5848": "66fb6c6b8683b37967e9d7f313b3df99a49d2406", + "canonical_main": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "scope": "One bounded C prototype; no newrational arithmetic, fixed16kcache/tokens, vectorcall+actual memberdescriptors, sameFIFO/counters. Genericoriginalfallback outsidevalidnativepacket.", + "gates": [ + "All964/54+9+10 inheritedchecks plusnativeprotocol/exception/GC/ownership/FIFO/buildsourcecontrols normalO beforeoneactualaudit.", + "Ccompilation andloading arepaidinsideeachfreshcompleteCcommand; externalcompilerCPUcountedby/usr/bin/time, notjustprocess_time.", + "No fullqualifier untilcrediblecomplete15%wallANDCPU afterallchecks/buildbill; firstpairthenBCCBBCmedians." + ], + "caps": { + "initial_seconds": 600, + "shared_seconds": 1500, + "command_seconds": 180, + "rss_bytes": 1073741824, + "serial": true, + "automatic_retries": 0 + }, + "goal_active": true, + "kappa_research": "PAUSED", + "reviewer": "Astra staticCAPI/refcount/ownership review; parentownsallimplementationandserialexecution" +} diff --git a/research/fraction-native-qualification/evidence/SCREEN.json b/research/fraction-native-qualification/evidence/SCREEN.json new file mode 100644 index 0000000000..2854ee67f9 --- /dev/null +++ b/research/fraction-native-qualification/evidence/SCREEN.json @@ -0,0 +1,29 @@ +{ + "decision": "CREDIBLE_COMPLETE_PAIR_AFTER_REVIEW_BINDING_CHECKS", + "not_complete_measurement": true, + "modeled_wall": 32.93958982103504, + "modeled_cpu": 32.758142364000015, + "modeled_wall_saving": 0.15571803213498303, + "modeled_cpu_saving": 0.15745518611111076, + "all_actual_values_types_witnesses_inputs": true, + "compile_paid_once": true, + "finite_bill": "entire observed debug finite command conservatively charged; remove only duplicated immutable compile", + "original_actual": { + "compiler_child_cpu_seconds": 0.0, + "cpu_seconds": 20.523067174, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "original", + "parent_cpu_seconds": 20.523067174, + "wall_seconds": 20.534678025986068 + }, + "native_actual": { + "compiler_child_cpu_seconds": 0.31187299999999996, + "cpu_seconds": 11.883082538000005, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "native-apply-cold", + "parent_cpu_seconds": 11.571209538000005, + "wall_seconds": 11.886980237992248 + }, + "coverage": "964 finite comparisons;73 inherited+41 native controls; normal/O/debug", + "new_bindings_require_recheck": true +} diff --git a/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/SCREEN.json b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/SCREEN.json new file mode 100644 index 0000000000..74ad222d9b --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/SCREEN.json @@ -0,0 +1,50 @@ +{ + "decision": "STOP_KEY_ONLY_BEFORE_COMPLETE_CONSTRUCTION", + "modeled_complete_wall": 33.52121791499667, + "modeled_complete_cpu": 33.35370983800001, + "modeled_wall_saving": 0.14081019283268814, + "modeled_cpu_saving": 0.14213709264403274, + "next_required_net_wall": 0.3585395521251513, + "next_required_net_cpu": 0.3057098380000056, + "not_complete_measurement": true, + "actual": { + "all_values_types_witnesses_inputs_equal": true, + "coordinates": 799, + "direct_add": false, + "events": 25984, + "not_complete_performance": true, + "observations": [ + { + "cpu_seconds": 20.388246467, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "original", + "wall_seconds": 20.39976386600756 + }, + { + "cpu_seconds": 13.453441415, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "entry-parent", + "wall_seconds": 13.468788220983697 + }, + { + "cpu_seconds": 12.921956305000002, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "compact-key", + "wall_seconds": 12.928807335993042 + } + ], + "status": "PASS_FULL_COMPACT_KEY_ACTUAL_AUDIT", + "table_statistics": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "weight_tokens": 3587 + }, + "finite_wall": 1.9772587239858694, + "finite_cpu": 1.94 +} diff --git a/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/STATE.json b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/STATE.json new file mode 100644 index 0000000000..0f3eff4f43 --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/STATE.json @@ -0,0 +1,57 @@ +{ + "stage": "STOP_KEY_ONLY_BEFORE_COMPLETE_CONSTRUCTION", + "goal_active": true, + "kappa_research": "PAUSED", + "runs": 0, + "screen": { + "decision": "STOP_KEY_ONLY_BEFORE_COMPLETE_CONSTRUCTION", + "modeled_complete_wall": 33.52121791499667, + "modeled_complete_cpu": 33.35370983800001, + "modeled_wall_saving": 0.14081019283268814, + "modeled_cpu_saving": 0.14213709264403274, + "next_required_net_wall": 0.3585395521251513, + "next_required_net_cpu": 0.3057098380000056, + "not_complete_measurement": true, + "actual": { + "all_values_types_witnesses_inputs_equal": true, + "coordinates": 799, + "direct_add": false, + "events": 25984, + "not_complete_performance": true, + "observations": [ + { + "cpu_seconds": 20.388246467, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "original", + "wall_seconds": 20.39976386600756 + }, + { + "cpu_seconds": 13.453441415, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "entry-parent", + "wall_seconds": 13.468788220983697 + }, + { + "cpu_seconds": 12.921956305000002, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "compact-key", + "wall_seconds": 12.928807335993042 + } + ], + "status": "PASS_FULL_COMPACT_KEY_ACTUAL_AUDIT", + "table_statistics": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "weight_tokens": 3587 + }, + "finite_wall": 1.9772587239858694, + "finite_cpu": 1.94 + }, + "next": "Separate source-bound property-to-slot key read feasibility before any construction or combination." +} diff --git a/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json new file mode 100644 index 0000000000..4b7e0b5b86 --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "micro-compact-key", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "022300c8970e9a8475735206f20dcf965d3dd26f03ccbfd3000716d03992e084", + "sampled_process_group_rss_bytes": 26951680, + "script": "micro.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "244b7982939faaa425f991062b547f901607661209c1714bb151249cde8db533", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1082, + "stdout_sha256": "0d41c44e7ea9bef7da4fe7f9601b6a23510c8746231cbf79ec594fb7c5b12d26", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 26180, + "system_seconds": 0.01, + "user_seconds": 1.08 + }, + "wall_seconds": 1.1367301769787446 +} diff --git a/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt new file mode 100644 index 0000000000..b63e50d55d --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt @@ -0,0 +1 @@ +{"not_full_performance": true, "order": "BCCB", "records": [{"cpu": 0.22844539799999997, "final_value": ["1", "0", "0", "0"], "label": "B", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.22845600498840213}, {"cpu": 0.17601116500000008, "final_value": ["1", "0", "0", "0"], "label": "C", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.1760264449985698}, {"cpu": 0.175548217, "final_value": ["1", "0", "0", "0"], "label": "C", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.17556217897799797}, {"cpu": 0.23951183600000003, "final_value": ["1", "0", "0", "0"], "label": "B", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.23956723097944632}], "status": "PASS_COMPACT_KEY_MICRO_ONLY", "steps_per_arm": 131072} diff --git a/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json new file mode 100644 index 0000000000..0e47962dce --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.08,"system_seconds":0.01,"kernel_max_rss_kib":26180,"exit":0} diff --git a/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json new file mode 100644 index 0000000000..dea1d82ebd --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json @@ -0,0 +1,6 @@ +{ + "failed_label": "finite-direct-add-freshness", + "cause": "New hostile-callable fixture was armed during classmethod construction and before its log existed; setup failed after inherited54controls, before freshness probe.", + "repair": "Construct classmethod with ordinary attribute reads first, initialize log, then arm hostile attribute behavior before the pure freshness check. No arithmetic or production implementation change.", + "automatic_retry": false +} diff --git a/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/SCREEN.json b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/SCREEN.json new file mode 100644 index 0000000000..3b14fdb76b --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/SCREEN.json @@ -0,0 +1,9 @@ +{ + "status": "STOP_DIRECT_ONLY_BEFORE_ACTUAL_OR_COMPLETE_CONSTRUCTION", + "micro_wall_difference": 0.013148339494364336, + "micro_cpu_difference": 0.013159579999999976, + "micro_steps": 131072, + "target_sites": 7739250, + "not_a_full_trace_or_accepted_projection": true, + "reason": "Illustrative micro scaling is only about0.78s before addedbinding/controlbill, not convincing headroom for the required0.794wall/.738CPU net beyond parent. Preserve semantics result and reassess a separate compact-key mechanism with direct addition disabled first." +} diff --git a/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/STATE.json b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/STATE.json new file mode 100644 index 0000000000..a477d16e6a --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/STATE.json @@ -0,0 +1,7 @@ +{ + "stage": "STOP_DIRECT_ONLY_BEFORE_ACTUAL_OR_COMPLETE_CONSTRUCTION", + "goal_active": true, + "kappa_research": "PAUSED", + "numerical_runs": 0, + "next": "Separate bounded compact-key assessment, then reassess before any combination or complete construction." +} diff --git a/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json new file mode 100644 index 0000000000..d3bced2c3f --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "micro-direct-add", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "97f5d5e29dca3428fcb48d12113bef05d701410cac35fe3b4bb130f4b0985a7f", + "sampled_process_group_rss_bytes": 28286976, + "script": "micro.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "2ffd9a5fb7c4d8c02d78561bedc490e29ac1dbba61b9c1a0b1471ead50e1c94a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 485, + "stdout_sha256": "cca5a795cb8100863e5e6cfc840b79e3811f9e2e199c3be01d07a1dc3c07e6a2", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 26172, + "system_seconds": 0.01, + "user_seconds": 0.63 + }, + "wall_seconds": 0.6582466270192526 +} diff --git a/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt new file mode 100644 index 0000000000..b11393fdc8 --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt @@ -0,0 +1 @@ +{"not_a_full_trace_or_performance_claim": true, "order": "BCCB", "records": [{"cpu": 0.104671191, "label": "B", "result": "6144", "wall": 0.10466263099806383}, {"cpu": 0.092273824, "label": "C", "result": "6144", "wall": 0.09234263902180828}, {"cpu": 0.09426316400000001, "label": "C", "result": "6144", "wall": 0.09425690298667178}, {"cpu": 0.10818495699999997, "label": "B", "result": "6144", "wall": 0.1082335899991449}], "status": "PASS_FIXED_MICRO_ONLY", "steps_per_arm": 131072} diff --git a/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json new file mode 100644 index 0000000000..0ae542e1cd --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json @@ -0,0 +1 @@ +{"user_seconds":0.63,"system_seconds":0.01,"kernel_max_rss_kib":26172,"exit":0} diff --git a/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json new file mode 100644 index 0000000000..32e5072db2 --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json @@ -0,0 +1,8 @@ +{ + "failed_label": "finite-slot-key", + "inherited": "All964/54+9 checks passed", + "cause": "The post-derive drift fixture changed Fraction.numerator values, poisoning Fraction equality itself; comparing two otherwise identical original outputs with == therefore fails.", + "repair": "Use an observable value-preserving getter replacement, compare getter-call counts before output equality, require original literal fallback. Preserve draft/receipt.", + "production_tightening": "Unsafe or overflowed weight-token metadata now uses literal original rather than cached generic; add unused corrupt-slot data fallback control.", + "automatic_retry": false +} diff --git a/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/STATE.json b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/STATE.json new file mode 100644 index 0000000000..315d85263c --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/STATE.json @@ -0,0 +1,5 @@ +{ + "stage": "SLOT_KEY_FINITE_FEASIBILITY", + "goal_active": true, + "kappa_research": "PAUSED" +} diff --git a/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json new file mode 100644 index 0000000000..5f6e634b65 --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "micro-slot-key", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "6981c68888c25ab48b527bcbb07ad156cf15113e8c304d458527eb3578e8e8f8", + "sampled_process_group_rss_bytes": 27860992, + "script": "micro.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "c0002580773c054149013e3f76cbd668a9a7e9e9087d4433226fa058fecc811f", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1092, + "stdout_sha256": "de8c34120ca983a6c0ef155909c2953be3864543d92215cb56cbfb4593173a5c", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 26124, + "system_seconds": 0.01, + "user_seconds": 0.47 + }, + "wall_seconds": 0.5072708880179562 +} diff --git a/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt new file mode 100644 index 0000000000..8810e0b1a8 --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt @@ -0,0 +1 @@ +{"not_complete_performance": true, "order": "BCCB", "records": [{"cpu": 0.05924658599999999, "final_value": ["1", "0", "0", "0"], "label": "B", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.05927750901901163}, {"cpu": 0.04855816399999996, "final_value": ["1", "0", "0", "0"], "label": "C", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.04856140600168146}, {"cpu": 0.04629298700000001, "final_value": ["1", "0", "0", "0"], "label": "C", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.0463139720086474}, {"cpu": 0.058482900000000004, "final_value": ["1", "0", "0", "0"], "label": "B", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.05851913499645889}], "status": "PASS_SLOT_KEY_MICRO_ONLY", "steps_per_arm": 131072} diff --git a/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json new file mode 100644 index 0000000000..9ef53ceb2f --- /dev/null +++ b/research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json @@ -0,0 +1 @@ +{"user_seconds":0.47,"system_seconds":0.01,"kernel_max_rss_kib":26124,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/GATE-2.json b/research/fraction-native-qualification/evidence/runtime/GATE-2.json new file mode 100644 index 0000000000..27a25d91cc --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/GATE-2.json @@ -0,0 +1,22 @@ +{ + "medians": { + "B": { + "wall": 40.19379291200312, + "cpu": 40.129999999999995 + }, + "C": { + "wall": 32.771296680002706, + "cpu": 32.74 + } + }, + "saving": { + "wall": 0.1846677234032279, + "cpu": 0.18415150760029886 + }, + "order": [ + "B1", + "C1" + ], + "all_full_receipts_equal": true, + "cold_compile_included": true +} diff --git a/research/fraction-native-qualification/evidence/runtime/GATE-6.json b/research/fraction-native-qualification/evidence/runtime/GATE-6.json new file mode 100644 index 0000000000..24b9b04190 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/GATE-6.json @@ -0,0 +1,26 @@ +{ + "medians": { + "B": { + "wall": 40.51615557898185, + "cpu": 40.33 + }, + "C": { + "wall": 32.771296680002706, + "cpu": 32.74 + } + }, + "saving": { + "wall": 0.19115483165428626, + "cpu": 0.18819737168361017 + }, + "order": [ + "B1", + "C1", + "C2", + "B2", + "B3", + "C3" + ], + "all_full_receipts_equal": true, + "cold_compile_included": true +} diff --git a/research/fraction-native-qualification/evidence/runtime/benchmark.py b/research/fraction-native-qualification/evidence/runtime/benchmark.py new file mode 100644 index 0000000000..9914ac8386 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/benchmark.py @@ -0,0 +1,40 @@ +"""Fresh cold BCCBBC; full original and every new finite/native check billed.""" +import json,statistics,sys +import guard +guard.SOURCE=guard.HERE.parent/'feasibility' +guard.CLOSURE=tuple(sorted(str(p.relative_to(guard.SOURCE)) for p in guard.SOURCE.rglob('*') if p.is_file() and '__pycache__' not in p.parts))+('/usr/lib/python3.12/fractions.py',) +guard.AGGREGATE=600 +sys.path.insert(0,str(guard.SOURCE)) +from frozen import payload,require +EXPECTED=json.loads(payload()['research/p104-single-pass-qualification/RESULT.json']) +ORDER=[('B1','full_B.py'),('C1','full_C.py'),('C2','full_C.py'),('B2','full_B.py'),('B3','full_B.py'),('C3','full_C.py')] + +def receipt(label): + p=guard.HERE/'runs'/label + r=json.loads((p/'receipt.json').read_text());require(r['status']=='PASS','full bounded command '+label) + out=json.loads((p/'stdout.txt').read_text().splitlines()[-1]);require(out['mode']=='qualify' and out['receipt']==EXPECTED,'unchanged full scientific receipt '+label) + if label.startswith('C'): + rows=[json.loads(x) for x in (p/'stdout.txt').read_text().splitlines() if x.startswith('{')] + require(sum(x.get('status')=='PASS_COMPLETE_NATIVE_COVERAGE' for x in rows)==1,'native and compiler coverage '+label) + return r + +def gate(labels): + groups={arm:[receipt(label) for label in labels if label.startswith(arm)] for arm in 'BC'} + medians={arm:dict(wall=statistics.median(x['wall_seconds'] for x in rows),cpu=statistics.median(x['usage']['user_seconds']+x['usage']['system_seconds'] for x in rows)) for arm,rows in groups.items()} + saving={k:1-medians['C'][k]/medians['B'][k] for k in ('wall','cpu')} + result=dict(medians=medians,saving=saving,order=labels,all_full_receipts_equal=True,cold_compile_included=True) + (guard.HERE/('GATE-'+str(len(labels))+'.json')).write_text(json.dumps(result,indent=2)+'\n') + require(min(saving.values())>=.15,'15% complete wall AND CPU gate') + return result + +require(len(sys.argv)==2 and sys.argv[1] in ('pair','remaining'),'pair or remaining') +with (guard.HERE/'execution.lock').open('a') as lock: + guard.fcntl.flock(lock,guard.fcntl.LOCK_EX|guard.fcntl.LOCK_NB) + if sys.argv[1]=='pair': + for label,script in ORDER[:2]:guard.run(label,script);receipt(label) + result=gate(['B1','C1']) + else: + gate(['B1','C1']) + for label,script in ORDER[2:]:guard.run(label,script);receipt(label) + result=gate([x[0] for x in ORDER]) + print(json.dumps(result,sort_keys=True)) diff --git a/research/fraction-native-qualification/evidence/runtime/dispatch.py b/research/fraction-native-qualification/evidence/runtime/dispatch.py new file mode 100644 index 0000000000..3b504562ef --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/dispatch.py @@ -0,0 +1,14 @@ +import sys +import guard +guard.SOURCE=guard.HERE.parent/'feasibility' +guard.CLOSURE=tuple(sorted(str(p.relative_to(guard.SOURCE)) for p in guard.SOURCE.rglob('*') if p.is_file() and '__pycache__' not in p.parts))+('/usr/lib/python3.12/fractions.py',) +guard.AGGREGATE=600 +label=sys.argv[1] +if label.endswith('-debug'): + guard.os.environ.update(PYTHONMALLOC='debug',PYTHONDEVMODE='1') +script='finite.py' if label.startswith('finite') else 'micro.py' if label.startswith('micro') else 'actual_audit.py' +if label.startswith('apply-micro'):script='micro_apply.py' +if label.startswith('full-'):script='full_C.py' +with (guard.HERE/'execution.lock').open('a') as lock: + guard.fcntl.flock(lock,guard.fcntl.LOCK_EX|guard.fcntl.LOCK_NB) + guard.run(label,script,optimized=label.endswith('-O')) diff --git a/research/fraction-native-qualification/evidence/runtime/guard.py b/research/fraction-native-qualification/evidence/runtime/guard.py new file mode 100644 index 0000000000..bf4265b129 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/guard.py @@ -0,0 +1,120 @@ +"""Serial bounded Linux measurements; preserve the complete frozen precision contract.""" +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import platform +import signal +import statistics +import subprocess +import sys +import tempfile +import time + +HERE = Path(__file__).resolve().parent +SOURCE = HERE +CLOSURE = ('frozen.py','primitive_profile.py','guard.py','dispatch.py','inputs/PR5848.tar','../feasibility/fraction_table.py','../feasibility/finite.py','/usr/lib/python3.12/fractions.py','../feasibility/actual_audit.py') +TIMEOUT = 180 +RSS_CAP = 1024**3 +OUTPUT_CAP = 2*1024**2 +AGGREGATE = 600 +PREVIOUS_WALL_SECONDS = 0 + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + +def inventory(): + result = {} + for name in CLOSURE: + path = SOURCE / name + if path.is_symlink() or not path.is_file(): + raise ValueError('Regular complete runtime file: ' + name) + result[name] = [sha(path.read_bytes()), path.stat().st_mode & 0o777] + return result + +def group_rss(group): + total = 0 + count = 0 + for p in Path('/proc').iterdir(): + if not p.name.isdigit(): + continue + try: + raw = (p/'stat').read_text() + fields = raw[raw.rfind(')')+2:].split() + if int(fields[2]) == group: + total += int(fields[21])*os.sysconf('SC_PAGE_SIZE') + count += 1 + except (FileNotFoundError, ProcessLookupError, PermissionError): + pass + return total, count + +def run(label, script, optimized=False): + records = HERE/'runs' + records.mkdir(exist_ok=True) + prior = list(records.glob('*/receipt.json')) + spent = PREVIOUS_WALL_SECONDS + sum(json.loads(p.read_bytes())['wall_seconds'] for p in prior) + if spent >= AGGREGATE: + raise ValueError('Aggregate budget consumed') + folder = records/label + folder.mkdir() + before = inventory() + env = os.environ.copy() + for key in ('PYTHONPATH','PYTHONOPTIMIZE','PYTHONINSPECT','PYTHONSTARTUP','PYTHONPYCACHEPREFIX'): + env.pop(key,None) + env.update(PYTHONHASHSEED='0', LC_ALL='C.UTF-8', TZ='UTC') + usage = folder/'usage.json' + with tempfile.TemporaryDirectory(prefix='linux5757-bytecode-') as cache: + command = ['/usr/bin/python3.12', '-B', '-X', 'pycache_prefix='+cache] + if optimized: + command.append('-O') + command.append(str(SOURCE/script)) + timed = ['/usr/bin/time','-f','{"user_seconds":%U,"system_seconds":%S,"kernel_max_rss_kib":%M,"exit":%x}', '-o', str(usage),'--',*command] + start = time.monotonic() + peak = 0 + stop = None + with (folder/'stdout.txt').open('wb') as out, (folder/'stderr.txt').open('wb') as err: + p = subprocess.Popen(timed, cwd=SOURCE, env=env, stdout=out, stderr=err, start_new_session=True) + try: + while p.poll() is None: + rss, _ = group_rss(p.pid) + peak = max(peak,rss) + elapsed = time.monotonic()-start + if rss > RSS_CAP: + stop='sampled_group_rss_cap' + elif elapsed > min(TIMEOUT,AGGREGATE-spent): + stop='wall_or_aggregate_cap' + elif max((folder/'stdout.txt').stat().st_size,(folder/'stderr.txt').stat().st_size)>OUTPUT_CAP: + stop='output_cap' + if stop: + os.killpg(p.pid,signal.SIGKILL) + break + time.sleep(0.05) + code=p.wait() + finally: + try: os.killpg(p.pid,signal.SIGKILL) + except ProcessLookupError: pass + p.wait() + elapsed = time.monotonic()-start + stdout=(folder/'stdout.txt').read_bytes() + stderr=(folder/'stderr.txt').read_bytes() + after=inventory() + measurement=None + if usage.exists(): + try: measurement=json.loads(usage.read_bytes()) + except json.JSONDecodeError: measurement={'raw':usage.read_text()} + receipt={'label':label,'script':script,'optimized':optimized,'wall_seconds':elapsed, + 'exit':code,'termination':stop,'sampled_process_group_rss_bytes':peak, + 'usage':measurement,'stdout_sha256':sha(stdout),'stdout_bytes':len(stdout), + 'stderr_sha256':sha(stderr),'stderr_bytes':len(stderr), + 'source_inventory_sha256':sha(json.dumps(before,sort_keys=True,separators=(',',':')).encode()), + 'source_bytes_and_modes_unchanged':before==after, + 'python':sys.version,'platform':platform.platform(), + 'runner_sha256':sha(Path(__file__).read_bytes()),'runtime_policy_sha256':sha(json.dumps(CLOSURE).encode())} + receipt['status']='PASS' if code==0 and stop is None and not stderr and before==after else 'STOP' + (folder/'receipt.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + print(json.dumps(receipt,sort_keys=True),flush=True) + if receipt['status']!='PASS': + raise SystemExit(1) + return receipt diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B1/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/B1/receipt.json new file mode 100644 index 0000000000..ec341c0150 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "B1", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 123207680, + "script": "full_B.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1086, + "stdout_sha256": "5a7ec74287edb31e6f401867c0eb2b4758a110e6e4131498226296a5f435cde9", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 118872, + "system_seconds": 0.08, + "user_seconds": 40.05 + }, + "wall_seconds": 40.19379291200312 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B1/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/B1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B1/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/B1/stdout.txt new file mode 100644 index 0000000000..1d9d2a70a1 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B1/stdout.txt @@ -0,0 +1,3 @@ +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 39.767559} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B1/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/B1/usage.json new file mode 100644 index 0000000000..14e15408ed --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B1/usage.json @@ -0,0 +1 @@ +{"user_seconds":40.05,"system_seconds":0.08,"kernel_max_rss_kib":118872,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B2/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/B2/receipt.json new file mode 100644 index 0000000000..deccaf5a8e --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B2/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "B2", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 123224064, + "script": "full_B.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1086, + "stdout_sha256": "cd094b9eea390f0c39922618b1e0b0a5b36f67ac59108755a475fc2930188ac0", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 118884, + "system_seconds": 0.11, + "user_seconds": 40.46 + }, + "wall_seconds": 41.037053946987726 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B2/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/B2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B2/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/B2/stdout.txt new file mode 100644 index 0000000000..fe5b7cc302 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B2/stdout.txt @@ -0,0 +1,3 @@ +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 40.630028} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B2/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/B2/usage.json new file mode 100644 index 0000000000..52abd76a09 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B2/usage.json @@ -0,0 +1 @@ +{"user_seconds":40.46,"system_seconds":0.11,"kernel_max_rss_kib":118884,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B3/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/B3/receipt.json new file mode 100644 index 0000000000..d5652ef3e8 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B3/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "B3", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 123383808, + "script": "full_B.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1086, + "stdout_sha256": "c358f72bcfe6d424948f4e17be786109fe95429acadc1e1ef33f120dd1ce3cd2", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 119040, + "system_seconds": 0.1, + "user_seconds": 40.23 + }, + "wall_seconds": 40.51615557898185 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B3/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/B3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B3/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/B3/stdout.txt new file mode 100644 index 0000000000..e2ca989c67 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B3/stdout.txt @@ -0,0 +1,3 @@ +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 40.142608} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/B3/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/B3/usage.json new file mode 100644 index 0000000000..16bba0c29e --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/B3/usage.json @@ -0,0 +1 @@ +{"user_seconds":40.23,"system_seconds":0.10,"kernel_max_rss_kib":119040,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C1/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/C1/receipt.json new file mode 100644 index 0000000000..d61dc4261f --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "C1", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 115896320, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14103, + "stdout_sha256": "94b8b578bdc812bf9c3a12e80bf2f00978000c6cc47119a180d4d003a1d0c20f", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111728, + "system_seconds": 0.2, + "user_seconds": 32.54 + }, + "wall_seconds": 32.771296680002706 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C1/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/C1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C1/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/C1/stdout.txt new file mode 100644 index 0000000000..483a20d08a --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C1/stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "0bb3ea54973df7923cabfa1aaab440e1ee5847e244fdcea126de8dbda7a1d73a", "cold_build_load_wall_seconds": 0.3246453919855412, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "0bb3ea54973df7923cabfa1aaab440e1ee5847e244fdcea126de8dbda7a1d73a", "cold_build_load_wall_seconds": 0.3246453919855412, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 30.019237} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C1/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/C1/usage.json new file mode 100644 index 0000000000..d3aecad589 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C1/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.54,"system_seconds":0.20,"kernel_max_rss_kib":111728,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C2/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/C2/receipt.json new file mode 100644 index 0000000000..f8e6215401 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C2/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "C2", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 116826112, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14105, + "stdout_sha256": "e5fae97b197190e7942f4af65ae80fdb7d8e57617640bdd268bb2774b2518e7c", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 112636, + "system_seconds": 0.2, + "user_seconds": 32.75 + }, + "wall_seconds": 33.03183611499844 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C2/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/C2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C2/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/C2/stdout.txt new file mode 100644 index 0000000000..bde4ca7336 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C2/stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "edfe5dc3887f683e221224b2612c0f6196f2c8fc917b7e73a01f488b3e0bb818", "cold_build_load_wall_seconds": 0.32343554199906066, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "edfe5dc3887f683e221224b2612c0f6196f2c8fc917b7e73a01f488b3e0bb818", "cold_build_load_wall_seconds": 0.32343554199906066, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 30.223509} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C2/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/C2/usage.json new file mode 100644 index 0000000000..645ef2cf8a --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C2/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.75,"system_seconds":0.20,"kernel_max_rss_kib":112636,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C3/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/C3/receipt.json new file mode 100644 index 0000000000..8225ad0284 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C3/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "C3", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 115761152, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14101, + "stdout_sha256": "56dc7baee49bc0aceabc9589593de191e31874345f83579664757ba96e40a193", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111596, + "system_seconds": 0.19, + "user_seconds": 32.31 + }, + "wall_seconds": 32.57126763599808 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C3/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/C3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C3/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/C3/stdout.txt new file mode 100644 index 0000000000..cf5431ba46 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C3/stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8a99dc259d7d897391ba3c0386ed8aed3a6f1e6566be48f792ab275cc3d65cce", "cold_build_load_wall_seconds": 0.323765334993368, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8a99dc259d7d897391ba3c0386ed8aed3a6f1e6566be48f792ab275cc3d65cce", "cold_build_load_wall_seconds": 0.323765334993368, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 29.924985} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/C3/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/C3/usage.json new file mode 100644 index 0000000000..685c9c0d2a --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/C3/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.31,"system_seconds":0.19,"kernel_max_rss_kib":111596,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/receipt.json new file mode 100644 index 0000000000..f0deab72ff --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "actual-native-apply", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 147218432, + "script": "actual_audit.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "e1f20ff8b51286e1fc8bd7e9af7f46432ff8453ef7a02bcccdd878697de62b7e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1831, + "stdout_sha256": "e68b03d1d1c96b980621d6dc35d471e4961c5684324d715f85ad746eeea430c5", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 108184, + "system_seconds": 0.11, + "user_seconds": 47.81 + }, + "wall_seconds": 48.00038802300696 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stdout.txt new file mode 100644 index 0000000000..fdadbf7244 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stdout.txt @@ -0,0 +1 @@ +{"all_values_types_witnesses_inputs_equal": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.3164052689971868, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "coordinates": 799, "direct_add": false, "events": 25984, "not_complete_performance": true, "observations": [{"compiler_child_cpu_seconds": 0.0, "cpu_seconds": 20.523067174, "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "label": "original", "parent_cpu_seconds": 20.523067174, "wall_seconds": 20.534678025986068}, {"compiler_child_cpu_seconds": 0.0, "cpu_seconds": 12.547595455, "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "label": "slot-parent", "parent_cpu_seconds": 12.547595455, "wall_seconds": 12.551854210993042}, {"compiler_child_cpu_seconds": 0.31187299999999996, "cpu_seconds": 11.883082538000005, "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "label": "native-apply-cold", "parent_cpu_seconds": 11.571209538000005, "wall_seconds": 11.886980237992248}], "status": "PASS_FULL_NATIVE_ACTUAL_AUDIT", "table_statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "weight_tokens": 3587} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/usage.json new file mode 100644 index 0000000000..5b74447409 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/usage.json @@ -0,0 +1 @@ +{"user_seconds":47.81,"system_seconds":0.11,"kernel_max_rss_kib":108184,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/receipt.json new file mode 100644 index 0000000000..3aef239968 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "apply-micro-native", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 75952128, + "script": "micro_apply.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "73551d162dde470d0e3ad0f472beb39e786c9df2cd434e0c0db0081dd1fceabd", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 7524, + "stdout_sha256": "3d02fcbf3cddbfe1bf4d8a80b8f40e579b3ea41ab4c14ee15b2044d7ac56d70c", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43952, + "system_seconds": 0.05, + "user_seconds": 1.57 + }, + "wall_seconds": 1.682075733988313 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stdout.txt new file mode 100644 index 0000000000..01c5f4261a --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stdout.txt @@ -0,0 +1 @@ +{"build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.3147972009901423, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "fixed_order": "BCCB", "results": [{"checksum": "20080", "cpu_seconds": 0.222510198, "label": "B", "last_row": {"0": "-3/4", "1": "-1/4", "10": "-1/2", "100": "-1/2", "102": "-1/4", "103": "1/4", "104": "3/4", "105": "-3/4", "106": "-1/4", "107": "1/4", "109": "1/2", "110": "-1/4", "111": "-1/2", "113": "1/2", "114": "1/4", "115": "-1/2", "117": "-1/4", "118": "1/4", "119": "3/4", "12": "-1/4", "120": "-3/4", "121": "-1/4", "122": "1/4", "124": "1/2", "125": "-1/4", "126": "-1/2", "13": "1/4", "14": "3/4", "15": "-3/4", "16": "-1/4", "17": "1/4", "19": "1/2", "2": "1/4", "20": "-1/4", "21": "-1/2", "23": "1/2", "24": "1/4", "25": "-1/2", "27": "-1/4", "28": "1/4", "29": "3/4", "30": "-3/4", "31": "-1/4", "32": "1/4", "34": "1/2", "35": "-1/4", "36": "-1/2", "38": "1/2", "39": "1/4", "4": "1/2", "40": "-1/2", "42": "-1/4", "43": "1/4", "44": "3/4", "45": "-3/4", "46": "-1/4", "47": "1/4", "49": "1/2", "5": "-1/4", "50": "-1/4", "51": "-1/2", "53": "1/2", "54": "1/4", "55": "-1/2", "57": "-1/4", "58": "1/4", "59": "3/4", "6": "-1/2", "60": "-3/4", "61": "-1/4", "62": "1/4", "64": "1/2", "65": "-1/4", "66": "-1/2", "68": "1/2", "69": "1/4", "70": "-1/2", "72": "-1/4", "73": "1/4", "74": "3/4", "75": "-3/4", "76": "-1/4", "77": "1/4", "79": "1/2", "8": "1/2", "80": "-1/4", "81": "-1/2", "83": "1/2", "84": "1/4", "85": "-1/2", "87": "-1/4", "88": "1/4", "89": "3/4", "9": "1/4", "90": "-3/4", "91": "-1/4", "92": "1/4", "94": "1/2", "95": "-1/4", "96": "-1/2", "98": "1/2", "99": "1/4"}, "last_scores": ["167/16", "241/32", "85/4"], "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65431, "misses": 105, "resident": 105}, "wall_seconds": 0.22254838500521146}, {"checksum": "20080", "cpu_seconds": 0.22580282900000004, "label": "C", "last_row": {"0": "-3/4", "1": "-1/4", "10": "-1/2", "100": "-1/2", "102": "-1/4", "103": "1/4", "104": "3/4", "105": "-3/4", "106": "-1/4", "107": "1/4", "109": "1/2", "110": "-1/4", "111": "-1/2", "113": "1/2", "114": "1/4", "115": "-1/2", "117": "-1/4", "118": "1/4", "119": "3/4", "12": "-1/4", "120": "-3/4", "121": "-1/4", "122": "1/4", "124": "1/2", "125": "-1/4", "126": "-1/2", "13": "1/4", "14": "3/4", "15": "-3/4", "16": "-1/4", "17": "1/4", "19": "1/2", "2": "1/4", "20": "-1/4", "21": "-1/2", "23": "1/2", "24": "1/4", "25": "-1/2", "27": "-1/4", "28": "1/4", "29": "3/4", "30": "-3/4", "31": "-1/4", "32": "1/4", "34": "1/2", "35": "-1/4", "36": "-1/2", "38": "1/2", "39": "1/4", "4": "1/2", "40": "-1/2", "42": "-1/4", "43": "1/4", "44": "3/4", "45": "-3/4", "46": "-1/4", "47": "1/4", "49": "1/2", "5": "-1/4", "50": "-1/4", "51": "-1/2", "53": "1/2", "54": "1/4", "55": "-1/2", "57": "-1/4", "58": "1/4", "59": "3/4", "6": "-1/2", "60": "-3/4", "61": "-1/4", "62": "1/4", "64": "1/2", "65": "-1/4", "66": "-1/2", "68": "1/2", "69": "1/4", "70": "-1/2", "72": "-1/4", "73": "1/4", "74": "3/4", "75": "-3/4", "76": "-1/4", "77": "1/4", "79": "1/2", "8": "1/2", "80": "-1/4", "81": "-1/2", "83": "1/2", "84": "1/4", "85": "-1/2", "87": "-1/4", "88": "1/4", "89": "3/4", "9": "1/4", "90": "-3/4", "91": "-1/4", "92": "1/4", "94": "1/2", "95": "-1/4", "96": "-1/2", "98": "1/2", "99": "1/4"}, "last_scores": ["167/16", "241/32", "85/4"], "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65431, "misses": 105, "resident": 105}, "wall_seconds": 0.22616888402262703}, {"checksum": "20080", "cpu_seconds": 0.18162575299999995, "label": "C", "last_row": {"0": "-3/4", "1": "-1/4", "10": "-1/2", "100": "-1/2", "102": "-1/4", "103": "1/4", "104": "3/4", "105": "-3/4", "106": "-1/4", "107": "1/4", "109": "1/2", "110": "-1/4", "111": "-1/2", "113": "1/2", "114": "1/4", "115": "-1/2", "117": "-1/4", "118": "1/4", "119": "3/4", "12": "-1/4", "120": "-3/4", "121": "-1/4", "122": "1/4", "124": "1/2", "125": "-1/4", "126": "-1/2", "13": "1/4", "14": "3/4", "15": "-3/4", "16": "-1/4", "17": "1/4", "19": "1/2", "2": "1/4", "20": "-1/4", "21": "-1/2", "23": "1/2", "24": "1/4", "25": "-1/2", "27": "-1/4", "28": "1/4", "29": "3/4", "30": "-3/4", "31": "-1/4", "32": "1/4", "34": "1/2", "35": "-1/4", "36": "-1/2", "38": "1/2", "39": "1/4", "4": "1/2", "40": "-1/2", "42": "-1/4", "43": "1/4", "44": "3/4", "45": "-3/4", "46": "-1/4", "47": "1/4", "49": "1/2", "5": "-1/4", "50": "-1/4", "51": "-1/2", "53": "1/2", "54": "1/4", "55": "-1/2", "57": "-1/4", "58": "1/4", "59": "3/4", "6": "-1/2", "60": "-3/4", "61": "-1/4", "62": "1/4", "64": "1/2", "65": "-1/4", "66": "-1/2", "68": "1/2", "69": "1/4", "70": "-1/2", "72": "-1/4", "73": "1/4", "74": "3/4", "75": "-3/4", "76": "-1/4", "77": "1/4", "79": "1/2", "8": "1/2", "80": "-1/4", "81": "-1/2", "83": "1/2", "84": "1/4", "85": "-1/2", "87": "-1/4", "88": "1/4", "89": "3/4", "9": "1/4", "90": "-3/4", "91": "-1/4", "92": "1/4", "94": "1/2", "95": "-1/4", "96": "-1/2", "98": "1/2", "99": "1/4"}, "last_scores": ["167/16", "241/32", "85/4"], "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65431, "misses": 105, "resident": 105}, "wall_seconds": 0.1816379169758875}, {"checksum": "20080", "cpu_seconds": 0.22555638100000008, "label": "B", "last_row": {"0": "-3/4", "1": "-1/4", "10": "-1/2", "100": "-1/2", "102": "-1/4", "103": "1/4", "104": "3/4", "105": "-3/4", "106": "-1/4", "107": "1/4", "109": "1/2", "110": "-1/4", "111": "-1/2", "113": "1/2", "114": "1/4", "115": "-1/2", "117": "-1/4", "118": "1/4", "119": "3/4", "12": "-1/4", "120": "-3/4", "121": "-1/4", "122": "1/4", "124": "1/2", "125": "-1/4", "126": "-1/2", "13": "1/4", "14": "3/4", "15": "-3/4", "16": "-1/4", "17": "1/4", "19": "1/2", "2": "1/4", "20": "-1/4", "21": "-1/2", "23": "1/2", "24": "1/4", "25": "-1/2", "27": "-1/4", "28": "1/4", "29": "3/4", "30": "-3/4", "31": "-1/4", "32": "1/4", "34": "1/2", "35": "-1/4", "36": "-1/2", "38": "1/2", "39": "1/4", "4": "1/2", "40": "-1/2", "42": "-1/4", "43": "1/4", "44": "3/4", "45": "-3/4", "46": "-1/4", "47": "1/4", "49": "1/2", "5": "-1/4", "50": "-1/4", "51": "-1/2", "53": "1/2", "54": "1/4", "55": "-1/2", "57": "-1/4", "58": "1/4", "59": "3/4", "6": "-1/2", "60": "-3/4", "61": "-1/4", "62": "1/4", "64": "1/2", "65": "-1/4", "66": "-1/2", "68": "1/2", "69": "1/4", "70": "-1/2", "72": "-1/4", "73": "1/4", "74": "3/4", "75": "-3/4", "76": "-1/4", "77": "1/4", "79": "1/2", "8": "1/2", "80": "-1/4", "81": "-1/2", "83": "1/2", "84": "1/4", "85": "-1/2", "87": "-1/4", "88": "1/4", "89": "3/4", "9": "1/4", "90": "-3/4", "91": "-1/4", "92": "1/4", "94": "1/2", "95": "-1/4", "96": "-1/2", "98": "1/2", "99": "1/4"}, "last_scores": ["167/16", "241/32", "85/4"], "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65431, "misses": 105, "resident": 105}, "wall_seconds": 0.2255811319919303}], "status": "PASS_NATIVE_APPLY_MICRO_ONLY", "updates_per_arm": 65536} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/usage.json new file mode 100644 index 0000000000..4057a5cd3b --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.57,"system_seconds":0.05,"kernel_max_rss_kib":43952,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/receipt.json new file mode 100644 index 0000000000..faef8eba4f --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-O", + "optimized": true, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "2787c5b5a49190f9181726808dd1bc8fb9110329451df0a650598f2a10e84fe2", + "sampled_process_group_rss_bytes": 78721024, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "e3d67435d792a554af13bd465a842da56b70aaeffde49bd4590266adcfdfd00f", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11770, + "stdout_sha256": "5958ee0382e335e0e57b25f0fded9c9ae3918f246bd959b7e76440451959fc18", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43888, + "system_seconds": 0.1, + "user_seconds": 2.41 + }, + "wall_seconds": 2.53013645199826 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stdout.txt new file mode 100644 index 0000000000..a120e5728f --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.32082126100431196, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/usage.json new file mode 100644 index 0000000000..2577953a5b --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.41,"system_seconds":0.10,"kernel_max_rss_kib":43888,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/receipt.json new file mode 100644 index 0000000000..03d370a5d2 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-bound-debug", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 81235968, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "dd17c6f6bfa6d484c93ac000f78186a42ef87669a2ce0ccfb7ca97a41afb96f8", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11834, + "stdout_sha256": "3ea12be81fa51a0f5d74ed668d55f36524f6aaeae7b76efd11624b3b86b15a87", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43752, + "system_seconds": 0.14, + "user_seconds": 2.95 + }, + "wall_seconds": 3.1384479379921686 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stdout.txt new file mode 100644 index 0000000000..dd71642695 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "fac2e410b80373947310853f08c7ed231b9f70320d78f1203b42f72f664d223c", "cold_build_load_wall_seconds": 0.3231552589859348, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 41, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/usage.json new file mode 100644 index 0000000000..3b8428a71e --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.95,"system_seconds":0.14,"kernel_max_rss_kib":43752,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json new file mode 100644 index 0000000000..77fac21517 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-cleanup-debug", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 81371136, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "73551d162dde470d0e3ad0f472beb39e786c9df2cd434e0c0db0081dd1fceabd", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11770, + "stdout_sha256": "d62396a142f6c365a13d31ed9db68f5a4efe702093d99a340cc73c8e97d4bfd1", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43780, + "system_seconds": 0.13, + "user_seconds": 2.7 + }, + "wall_seconds": 2.8887771570007317 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt new file mode 100644 index 0000000000..5e87740383 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.31362746001104824, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/usage.json new file mode 100644 index 0000000000..664eaf4904 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.70,"system_seconds":0.13,"kernel_max_rss_kib":43780,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json new file mode 100644 index 0000000000..d30e36ba55 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-debug-cleanup", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 77979648, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "73551d162dde470d0e3ad0f472beb39e786c9df2cd434e0c0db0081dd1fceabd", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11769, + "stdout_sha256": "406ad2c71dde19af5e4c9997c46c6ceb8a6a327c12c8213b4617efef47e87221", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 44000, + "system_seconds": 0.12, + "user_seconds": 2.41 + }, + "wall_seconds": 2.586756376986159 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt new file mode 100644 index 0000000000..e41069639c --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.3298818950133864, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/usage.json new file mode 100644 index 0000000000..ba8acb9713 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.41,"system_seconds":0.12,"kernel_max_rss_kib":44000,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/receipt.json new file mode 100644 index 0000000000..3b95662ddc --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-debug", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "2787c5b5a49190f9181726808dd1bc8fb9110329451df0a650598f2a10e84fe2", + "sampled_process_group_rss_bytes": 80912384, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "e3d67435d792a554af13bd465a842da56b70aaeffde49bd4590266adcfdfd00f", + "status": "STOP", + "stderr_bytes": 185, + "stderr_sha256": "1e58b0030f6a620590941fd889e912b49605b16d6bff0cdb0269317305a56877", + "stdout_bytes": 11769, + "stdout_sha256": "517ab979ea958fdadf2c9e9542421752677cabe5ea1595658bb6535d51e07ad1", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43952, + "system_seconds": 0.11, + "user_seconds": 2.72 + }, + "wall_seconds": 2.8839498269953765 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stderr.txt new file mode 100644 index 0000000000..7275b618d7 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stderr.txt @@ -0,0 +1,2 @@ +/usr/lib/python3.12/tempfile.py:1075: ResourceWarning: Implicitly cleaning up + _warnings.warn(warn_message, ResourceWarning) diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stdout.txt new file mode 100644 index 0000000000..f8a8d0869d --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.3027255790075287, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/usage.json new file mode 100644 index 0000000000..267e4d9b05 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.72,"system_seconds":0.11,"kernel_max_rss_kib":43952,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/receipt.json new file mode 100644 index 0000000000..05299d286c --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-final-debug", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 80936960, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "64231ec17a585015124a8ebfb0ff8f1e18176ca3c6e2a8125333cbbf6040ff1d", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11835, + "stdout_sha256": "b1b4336083ec54f132ec96e3d32253bce249ec2d79e8e790b7151dc3a913b5a6", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43736, + "system_seconds": 0.13, + "user_seconds": 3.05 + }, + "wall_seconds": 3.2485531510028522 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stdout.txt new file mode 100644 index 0000000000..07800f5480 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "576df287369ec83fbed9a22dbae9de171d4dd3d08767ef3de252fc5dae708531", "cold_build_load_wall_seconds": 0.32178150399704464, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 41, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/usage.json new file mode 100644 index 0000000000..169c410243 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/usage.json @@ -0,0 +1 @@ +{"user_seconds":3.05,"system_seconds":0.13,"kernel_max_rss_kib":43736,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/receipt.json new file mode 100644 index 0000000000..449069b1c7 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-initial", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "787d19d195e2a2fdfb91f1a2798e96d7291c1c63431bd8c0ad4830ac0070d19e", + "sampled_process_group_rss_bytes": 77836288, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "1fe97ee94c9617e6d9ed7fb1297ec7a1042cb874155a4dd91973975322e19942", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11769, + "stdout_sha256": "132dbf612655631727322fe5e75c64009ec0d27edfc36e24c7f5c7802dd8a60b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43268, + "system_seconds": 0.12, + "user_seconds": 2.39 + }, + "wall_seconds": 2.682428517990047 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stdout.txt new file mode 100644 index 0000000000..718b715088 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.5364224890072364, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/usage.json new file mode 100644 index 0000000000..4304aa4876 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.39,"system_seconds":0.12,"kernel_max_rss_kib":43268,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/receipt.json new file mode 100644 index 0000000000..c73b3693bc --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/receipt.json @@ -0,0 +1,23 @@ +{ + "exit": 1, + "label": "finite-native-packet-O", + "optimized": true, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 78438400, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "eb4d294b159acd91e48a11348e321e41c3b1093f62d19ab3bc50ace7b433c7b5", + "status": "STOP", + "stderr_bytes": 625, + "stderr_sha256": "6234cdc3b985c9e4355437da48846e852d1ba11ce8d15814ec3711734f38b3d8", + "stdout_bytes": 7318, + "stdout_sha256": "888063666924c013dbce1b2f199c90c90f87742cc09a423e6e335dba926a51fb", + "termination": null, + "usage": { + "raw": "Command exited with non-zero status 1\n{\"user_seconds\":3.17,\"system_seconds\":0.12,\"kernel_max_rss_kib\":43456,\"exit\":1}\n" + }, + "wall_seconds": 3.376391716010403 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stderr.txt new file mode 100644 index 0000000000..62ac60af11 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stderr.txt @@ -0,0 +1,8 @@ +Traceback (most recent call last): + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/fraction-native-cache-20261027/feasibility/finite.py", line 155, in + if __name__=='__main__':main() + ^^^^^^ + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/fraction-native-cache-20261027/feasibility/finite.py", line 128, in main + else:raise ValueError('constructor mutation was not rejected') + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +ValueError: constructor mutation was not rejected diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stdout.txt new file mode 100644 index 0000000000..0991e5508f --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stdout.txt @@ -0,0 +1,4 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/usage.json new file mode 100644 index 0000000000..8c2bc0490a --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/usage.json @@ -0,0 +1,2 @@ +Command exited with non-zero status 1 +{"user_seconds":3.17,"system_seconds":0.12,"kernel_max_rss_kib":43456,"exit":1} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/receipt.json new file mode 100644 index 0000000000..0a12987700 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-reviewed-O", + "optimized": true, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 78131200, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "e1f20ff8b51286e1fc8bd7e9af7f46432ff8453ef7a02bcccdd878697de62b7e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11835, + "stdout_sha256": "83c424e31cc422df948afa1f7ee1d716a4336144a12f893bc39cfee6ebfe6d36", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43712, + "system_seconds": 0.1, + "user_seconds": 2.56 + }, + "wall_seconds": 2.686613911006134 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt new file mode 100644 index 0000000000..0d93e94552 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.32369362501776777, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 41, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/usage.json new file mode 100644 index 0000000000..16ebf521bd --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.56,"system_seconds":0.10,"kernel_max_rss_kib":43712,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/receipt.json new file mode 100644 index 0000000000..aa53b9aac9 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-snapshot-O", + "optimized": true, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 78516224, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "a1a837e3b495b14c37389deecba442c44ef17f07b45dfeb2aa46f93aca98331d", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11948, + "stdout_sha256": "9305bbb70a364966598fbd21cc340202eca4915ad01bc6f7ba1409c2af55e519", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43800, + "system_seconds": 0.13, + "user_seconds": 2.55 + }, + "wall_seconds": 2.735172514017904 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt new file mode 100644 index 0000000000..ca62de4dab --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "58bdc232837c7be4adb4c9ea3c26b921c55e0ae71886e1d8fd37409716e8600d", "cold_build_load_wall_seconds": 0.33438298499095254, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/usage.json new file mode 100644 index 0000000000..f7b5b7b02e --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.55,"system_seconds":0.13,"kernel_max_rss_kib":43800,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/receipt.json new file mode 100644 index 0000000000..a57be41a5b --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-native-O", + "optimized": true, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 116686848, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14103, + "stdout_sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 112500, + "system_seconds": 0.18, + "user_seconds": 32.33 + }, + "wall_seconds": 32.580494505004026 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stdout.txt new file mode 100644 index 0000000000..c26b54d68b --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "0f12f0ce53dc87222465784fc58dcc852c209ab3c71d3f183c85db08c74d3826", "cold_build_load_wall_seconds": 0.3294046340161003, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "0f12f0ce53dc87222465784fc58dcc852c209ab3c71d3f183c85db08c74d3826", "cold_build_load_wall_seconds": 0.3294046340161003, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 29.794405} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/usage.json new file mode 100644 index 0000000000..cf159e98e6 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/full-native-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.33,"system_seconds":0.18,"kernel_max_rss_kib":112500,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/micro-native/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/micro-native/receipt.json new file mode 100644 index 0000000000..9432927459 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/micro-native/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "micro-native", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "2787c5b5a49190f9181726808dd1bc8fb9110329451df0a650598f2a10e84fe2", + "sampled_process_group_rss_bytes": 74960896, + "script": "micro.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "d618febc8e0d593a3a459bf56cf622fe4e7bcd13f72b77341332797d3c0f516a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1708, + "stdout_sha256": "9e4aa00d01e596696171b4c4ca70451359bc8e57433c169d11180c25b38643e9", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43672, + "system_seconds": 0.04, + "user_seconds": 1.18 + }, + "wall_seconds": 1.2924172079947311 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/micro-native/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/micro-native/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/micro-native/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/micro-native/stdout.txt new file mode 100644 index 0000000000..b878a1cc00 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/micro-native/stdout.txt @@ -0,0 +1 @@ +{"build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.31328881898662075, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "fixed_order": "BCCB", "results": [{"cpu_seconds": 0.11537545099999996, "label": "B", "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65532, "misses": 4, "resident": 4}, "total": "393216", "wall_seconds": 0.11537122199661098}, {"cpu_seconds": 0.12363816999999999, "label": "C", "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65532, "misses": 4, "resident": 4}, "total": "393216", "wall_seconds": 0.12369171800673939}, {"cpu_seconds": 0.13746958999999992, "label": "C", "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65532, "misses": 4, "resident": 4}, "total": "393216", "wall_seconds": 0.13854740900569595}, {"cpu_seconds": 0.11428460200000001, "label": "B", "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65532, "misses": 4, "resident": 4}, "total": "393216", "wall_seconds": 0.11428235299536027}], "status": "PASS_NATIVE_MICRO_SCREEN_ONLY", "updates_per_arm": 65536} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/micro-native/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/micro-native/usage.json new file mode 100644 index 0000000000..a6e059160a --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/micro-native/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.18,"system_seconds":0.04,"kernel_max_rss_kib":43672,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/receipt.json new file mode 100644 index 0000000000..816d6ec8fd --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "packaged-native-finite-O", + "optimized": true, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "915a89f16cff26648e9fa7387bba5b60edaa585ad520cf6026bfe1d575bbc237", + "sampled_process_group_rss_bytes": 78098432, + "script": "verify.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "dd668ce315f27bd03758656461f80f600d7f510ed251751fd8cc167b51fa99b5", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 12183, + "stdout_sha256": "e2f4c31106c5391b090c20762ad751450f4482be5b2d837f5533bd96c5d5157b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43628, + "system_seconds": 0.14, + "user_seconds": 2.47 + }, + "wall_seconds": 2.6385492559929844 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stdout.txt new file mode 100644 index 0000000000..002652f850 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stdout.txt @@ -0,0 +1,7 @@ +PASS_PRECISION_LINUX_SOURCE_CONTROLS {"contract": "declared contract edits", "declared_edit": "unique backend seam", "inner_archive": "source hash", "official_export_byte": "Exact PR5831 bundle"} +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "ec97f6ab576e23680c1fa6e0b3d6d9533a10ca0d7728aa7b21b7393ca0635360", "cold_build_load_wall_seconds": 0.3090584030142054, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +PASS_FRACTION_NATIVE_FINITE_AND_CUSTODY diff --git a/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/usage.json new file mode 100644 index 0000000000..81ad6268c0 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.47,"system_seconds":0.14,"kernel_max_rss_kib":43628,"exit":0} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/receipt.json b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/receipt.json new file mode 100644 index 0000000000..d32188ccb7 --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "packaged-native-finite", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "915a89f16cff26648e9fa7387bba5b60edaa585ad520cf6026bfe1d575bbc237", + "sampled_process_group_rss_bytes": 78401536, + "script": "verify.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "dd668ce315f27bd03758656461f80f600d7f510ed251751fd8cc167b51fa99b5", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 12183, + "stdout_sha256": "b9f8cd5829de1799caa90e5101bb9e6dd28d9c61eef93fcc9a4c17ff561199ab", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 44092, + "system_seconds": 0.13, + "user_seconds": 2.5 + }, + "wall_seconds": 2.6823815919924527 +} diff --git a/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stderr.txt b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stdout.txt b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stdout.txt new file mode 100644 index 0000000000..c04cc0b9ce --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stdout.txt @@ -0,0 +1,7 @@ +PASS_PRECISION_LINUX_SOURCE_CONTROLS {"contract": "declared contract edits", "declared_edit": "unique backend seam", "inner_archive": "source hash", "official_export_byte": "Exact PR5831 bundle"} +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "14e39fdbdd9a3d15962a1e5aa387b8dc0a06d193f2f73d953f13d039b2f7587e", "cold_build_load_wall_seconds": 0.3222606969939079, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +PASS_FRACTION_NATIVE_FINITE_AND_CUSTODY diff --git a/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/usage.json b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/usage.json new file mode 100644 index 0000000000..e0924173bd --- /dev/null +++ b/research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.50,"system_seconds":0.13,"kernel_max_rss_kib":44092,"exit":0} diff --git a/research/fraction-native-qualification/finite.py b/research/fraction-native-qualification/finite.py new file mode 100644 index 0000000000..628b3a6e34 --- /dev/null +++ b/research/fraction-native-qualification/finite.py @@ -0,0 +1,146 @@ +"""Full inherited scientific gate and bounded native ownership/API controls.""" +import gc,json,sys,weakref,importlib.util +from fractions import Fraction as F +import native_backend +import fraction_table as table +import slot_finite +from frozen import require,baseline +from compact_finite import types_of + +def main(): + inherited=slot_finite.main();controls=[];native=native_backend.load() + weights=[(F(2),F(3)),(F(5),F(7)),(F(4,2),F(6,2))];tokens=[0,1,0] + compute=table.Contributions.compute + def make(cap=2,fn=compute,ws=None,ts=None):return native.Cache(cap,weights if ws is None else ws,tokens if ts is None else ts,fn,F.__dict__['_numerator'],F.__dict__['_denominator'],F) + def rejects(action,kind,label): + try:action() + except kind:controls.append(label) + else:raise ValueError('accepted '+label) + for cap in (1,2,16): + old=table.Contributions(cap);old.certify(dict(public=1,owned_fields=0,program=[]),weights,set());new=make(cap) + for q in (F(1),F(-1),F(1,2),F(2,4),F(2)): + event=new.event(q) + for k,i in enumerate((0,1,2,0,1,0,2,2,1)): + a,v=F(k%2),F(k%3-1) + require(event(a,v,i)==old.step(a,q,v,*weights[i]),'native value/FIFO') + require(new.statistics()==old.statistics(),'native full counters') + controls.append('canonical-keys-FIFO-wrap-counters') + c=make();event=c.event(F(1));modulus=sys.hash_info.modulus + a=event(F(0),F(1),0);b=event(F(modulus),F(1),0) + require(a!=b and c.statistics()['misses']==2,'native full equality on integer hash collision') + controls.append('native-hash-collision') + log=[] + def observed(*args):log.append(args);return compute(*args) + c=make(fn=observed);e=c.event(F(1));a=e(F(0),F(1),0);b=e(F(0),F(1),0) + require(a is b and len(log)==1,'hit returns owned existing tuple; no arithmetic') + controls.append('exact-one-callback-per-miss') + def fails(*args):raise ArithmeticError('original callback failure') + c=make(fn=fails);e=c.event(F(1)) + for k in range(2):rejects(lambda:e(F(0),F(1),0),ArithmeticError,'uncached-native-error-'+str(k)) + require(c.statistics()['resident']==0 and c.statistics()['misses']==2,'failed callback never cached') + gate=[False] + def intermittent(*args): + if gate[0]:raise ArithmeticError('full miss') + return compute(*args) + c=make(1,intermittent);e=c.event(F(1));e(F(0),F(1),0);gate[0]=True + rejects(lambda:e(F(2),F(1),0),ArithmeticError,'full-cache-failure-before-eviction') + require(c.statistics()['resident']==1 and c.statistics()['evictions']==0,'failed miss retains FIFO') + require(e(F(0),F(1),0)==compute(F(0),F(1),F(1),*weights[0]),'existing cache hit after failure') + controls.append('cache-survives-callback-exception') + c=make();e=c.event(F(1)) + for cap in (0,-1,16385,True,1.5,10**100):rejects(lambda cap=cap:make(cap),(ValueError,OverflowError),'capacity-'+str(cap)) + for i in (-1,3,10**100,True,'0'):rejects(lambda i=i:e(F(0),F(1),i),(TypeError,IndexError,OverflowError),'index-'+str(i)) + rejects(lambda:e(F(0),F(1)),TypeError,'arity') + rejects(lambda:e(F(0),F(1),0,extra=1),TypeError,'keywords') + rejects(lambda:e(0,F(1),0),TypeError,'exact-operand') + rejects(lambda:c.event(1),TypeError,'exact-scalar') + rejects(lambda:type(e)(),TypeError,'event-creation') + rejects(lambda:native.Cache(2,weights,tokens,compute,object(),F.__dict__['_denominator'],F),TypeError,'descriptor-protocol') + rejects(lambda:make(ts=[0]),ValueError,'token-length') + rejects(lambda:make(ts=[0,-1,1]),ValueError,'token-range') + rejects(lambda:make(ws=[(F(1),)]),ValueError,'partial-init-length') + rejects(lambda:make(ws=[(1,F(1))]*3),TypeError,'partial-init-weight') + def malformed(*args):return (F(1),)*3 + e=make(fn=malformed).event(F(1));rejects(lambda:e(F(0),F(1),0),TypeError,'callback-result-shape') + def malformed(*args):return (F(1),F(1),F(1),1) + e=make(fn=malformed).event(F(1));rejects(lambda:e(F(0),F(1),0),TypeError,'callback-result-type') + holder=[] + def recursive(*args):return holder[0](F(0),F(1),0) + c=make(fn=recursive);holder.append(c.event(F(1))) + rejects(lambda:holder[0](F(0),F(1),0),RuntimeError,'callback-reentry') + require(c.statistics()['calls']==1 and c.statistics()['resident']==0,'reentry cannot mutate cache') + del holder[:] + c=make();e=c.event(F(1));del c;gc.collect() + require(e(F(0),F(1),0)==compute(F(0),F(1),F(1),*weights[0]),'Event owns parent/context') + controls.append('event-owns-parent') + def cycle(): + context=[] + def callback(*args):return compute(*args) if context else None + c=make(fn=callback);context.append(c);return weakref.ref(callback) + ref=cycle();gc.collect();require(ref() is None,'callback/cache cycle collected') + controls.append('GC-callback-cycle') + c=make();s=c.statistics();s['calls']=-1;require(c.statistics()['calls']==0,'statistics isolated');controls.append('native-statistics-isolated') + src={0:F(1),1:F(-1),2:F(2)};dst={0:F(1)};scores=[F(3),F(4),F(5)] + expected=dict(dst);expected_scores=list(scores);parent=table.parent.CompactContributions(2,weights,tokens);step=parent.event(F(-1)) + for i,v in src.items(): + value,a,b,change=step(expected.get(i,F(0)),v,i) + expected_scores[0]+=a;expected_scores[1]+=b;expected_scores[2]+=change + if value:expected[i]=value + else:expected.pop(i,None) + c=make();c.event(F(-1)).apply(dst,src,scores) + require((dst,scores)==(expected,expected_scores) and types_of((dst,scores))==types_of((expected,expected_scores)) and c.statistics()==parent.statistics(),'complete native apply values/types/counters') + controls.append('native-coefficient-loop') + rejects(lambda:c.event(F(1)).apply(dst,dst,scores),TypeError,'same-row-lowlevel-rejection') + def mutate(*args):src.clear();return compute(*args) + src={0:F(1)};e=make(fn=mutate).event(F(1)) + rejects(lambda:e.apply({},src,[F(0)]*3),RuntimeError,'dict-iterator-mutation-safe') + scores=[F(0)]*3 + def mutate_score(*args):scores.clear();return compute(*args) + e=make(fn=mutate_score).event(F(1)) + rejects(lambda:e.apply({}, {0:F(1)},scores),IndexError,'callback-list-mutation-safe') + require(native_backend.source_hash()==native_backend.receipt()['source_sha256'],'compiled source remains bound') + controls.append('native-source-authenticated') + normal=table.Contributions.__dict__.get('compute');had='compute' in table.Contributions.__dict__;log=[] + class ForeignCompute: + def __get__(self,*args):log.append(True);raise RuntimeError('foreign compute must not be invoked') + try: + table.Contributions.compute=ForeignCompute() + require(table.checked_compute() is None and not log,'foreign callback descriptor rejected purely') + controls.append('callback-descriptor-is-pure') + table.Contributions.compute=compute + require(table.checked_compute() is None,'plain function would bind self; not staticmethod') + controls.append('plain-callback-rejected') + finally: + if had:table.Contributions.compute=normal + else:del table.Contributions.compute + code=compute.__code__;compute.__code__=code.replace(co_consts=code.co_consts+('drift',)) + try:require(table.checked_compute() is None,'live callback executable bound') + finally:compute.__code__=code + controls.append('live-callback-code-drift') + ws=[(F(2),F(3))];ts=[0] + owned=make(ws=ws,ts=ts);event=owned.event(F(1));ws.clear();ts.clear();gc.collect() + require(event(F(0),F(1),0)==compute(F(0),F(1),F(1),F(2),F(3)),'owned immutable packet survives caller metadata mutation') + controls.append('owned-metadata-snapshot') + with baseline() as package: + sys.path.insert(0,str(package));spec=importlib.util.spec_from_file_location('native_fallback_bundle',package/'source.py') + source=importlib.util.module_from_spec(spec);spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('native_fallback_source',p/'verify.py');v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,_,ref): + original=ref.error_trace;fast=table.derive(ref) + word=dict(public=1,owned_fields=0,program=[['INIT',0,0],['ADD',0,0,1,0]]) + ws=[(F(1),F(1))]*2 + require(fast(word,ws,set())==original(word,ws,set()) and not fast.compacted_selected(),'same-row literal fallback') + controls.append('same-row-source-fallback') + bad=object.__new__(F) + word=dict(public=2,owned_fields=0,program=[['ADD',0,1,bad,0]]) + outcomes=[] + for fn in (original,fast): + try:outcomes.append(('value',fn(word,ws,set()))) + except Exception as error:outcomes.append((type(error).__name__,str(error))) + require(outcomes[0]==outcomes[1] and not fast.compacted_selected(),'malformed Fraction scalar has literal source outcome') + controls.append('malformed-scalar-literal-fallback') + result=dict(status='PASS_NATIVE_FINITE_ONLY',inherited=inherited,native_controls=controls,native_control_count=len(controls),build=native_backend.receipt(),all_coverage_preserved=True) + print(json.dumps(result,sort_keys=True));return result + +if __name__=='__main__':main() diff --git a/research/fraction-native-qualification/fraction_table.py b/research/fraction-native-qualification/fraction_table.py new file mode 100644 index 0000000000..d1688f4049 --- /dev/null +++ b/research/fraction-native-qualification/fraction_table.py @@ -0,0 +1,118 @@ +"""Native bookkeeping with original Fraction miss/score arithmetic.""" +from contextlib import contextmanager +from hashlib import sha256 +import inspect +import builtins +from types import FunctionType +from pathlib import Path +import slot_parent as parent +import native_backend +from slot_binding import bind,fresh + +F=parent.F;CAPACITY=parent.CAPACITY +Contributions=parent.Contributions;NORMAL_CONTRIBUTIONS=Contributions +certified_domain=parent.certified_domain +transformed=parent.transformed +weight_tokens=parent.weight_tokens +_known={} +_ABS=builtins.abs +exec('def compute(old,q,v,a,c):\n value=old+q*v\n change=abs(value)-abs(old)\n return value,change*a,change*c,change\n',_known) + +def checked_compute(): + if type(Contributions) is not type:return None + descriptor=None + for cls in type.__getattribute__(Contributions,'__mro__'): + namespace=type.__getattribute__(cls,'__dict__') + if 'compute' in namespace: + descriptor=namespace['compute'];break + if type(descriptor) is not staticmethod:return None + fn=descriptor.__func__ + if type(fn) is not FunctionType:return None + if fn.__defaults__ is not None or fn.__kwdefaults__ is not None or fn.__closure__ is not None:return None + source=parent.parent.entry.parent + if source.code_shape(fn.__code__)!=source.code_shape(_known['compute'].__code__):return None + if type(fn.__builtins__) is not dict:return None + effective=fn.__globals__.get('abs',fn.__builtins__.get('abs')) + return fn if effective is _ABS else None + +class CompactContributions: + def __init__(self,capacity,weights,tokens): + callback=checked_compute() + if callback is None:raise ValueError('qualified original Fraction miss callback') + self.native=native_backend.load().Cache(capacity,weights,tokens,callback,F.__dict__['_numerator'],F.__dict__['_denominator'],F) + def event(self,q):return self.native.event(q) + def statistics(self):return self.native.statistics() + +def native_domain(word,weights): + n=word['public']+word['owned_fields'] + if n<0 or word['public']<0 or word['owned_fields']<0 or len(weights)','exec'),namespace) + source.need(source.code_shape(original.__code__)==source.code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + source.need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + token=bind();last=[None,None,None];factory=Contributions + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:factory(capacity),_contribution_report=report, + _compact_factory=lambda weights,tokens:CompactContributions(capacity,weights,tokens)) + exec(compile(safe,'','exec'),namespace);generic=namespace['error_trace'] + exec(compile(compact,'','exec'),namespace);specialized=namespace['error_trace'] + def call(word,weights,rounded): + last[:]=[None,False,None] + if token is None or not fresh(token):return original(word,weights,rounded) + eligible=bool(capacity and factory is NORMAL_CONTRIBUTIONS and checked_compute() is not None and certified_domain(word,weights,rounded)) + if eligible and not native_domain(word,weights):return original(word,weights,rounded) + tokens=weight_tokens(weights) if eligible else None + if eligible and tokens is None:return original(word,weights,rounded) + last[1]=tokens is not None;last[2]=None if tokens is None else (max(tokens)+1 if tokens else 0) + return specialized(word,weights,rounded,tokens) if tokens is not None else generic(word,weights,rounded) + call.statistics=lambda:None if last[0] is None else dict(last[0]) + call.compacted_selected=lambda:last[1] + call.token_count=lambda:last[2] + return call + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace;derived=derive(reference,capacity);reference.error_trace=derived + try:yield derived + finally:reference.error_trace=original diff --git a/research/fraction-native-qualification/full.py b/research/fraction-native-qualification/full.py new file mode 100644 index 0000000000..93196e8d63 --- /dev/null +++ b/research/fraction-native-qualification/full.py @@ -0,0 +1,54 @@ +"""Complete frozen qualifier with one source-bound Fraction seam changed.""" +import importlib.util,inspect,json,sys +from pathlib import Path +from frozen import baseline,require + +ACTUAL_STATS=dict(calls=2579750,hits=2252966,misses=326784,evictions=310400,bypasses=0,resident=16384,capacity=16384) +OUTPUT='954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9' + +def main(native=False): + if native: + import finite + finite.main() + # The inherited finite harness imports its own sealed temporary source. + # Remove only expired, owned temporary modules before the fresh qualifier. + for name in ('source','observe'): + value=sys.modules.get(name);file=getattr(value,'__file__','') + if file.startswith('/tmp/precision-linux-source-') and not Path(file).exists():del sys.modules[name] + with baseline() as package: + sys.path.insert(0,str(package)) + spec=importlib.util.spec_from_file_location('native_complete_frozen_entry',package/'candidate.py') + entry=importlib.util.module_from_spec(spec);spec.loader.exec_module(entry) + if not native: + entry.main();return + import fraction_table,native_backend + captures=[] + def native_trace(reference,expected_word): + trace=fraction_table.derive(reference) + def call(word,weights,rounded): + result=trace(word,weights,rounded) + if len(word['program'])==len(expected_word['program']): + require(trace.compacted_selected() is True,'actual native route selected') + require(trace.statistics()==ACTUAL_STATS,'all actual native counters') + require(reference.digest(result)==OUTPUT,'complete actual native output digest') + captures.append(dict(statistics=trace.statistics(),output_sha256=OUTPUT,tokens=trace.token_count())) + return result + return call + raw=(package/'candidate.py').read_text() + seam=' value = Observation(value, reference.digest, word)\n' + require(raw.count(seam)==1,'one authenticated actual Fraction seam') + changed=raw.replace(seam,' value.error_trace = _native_trace(value, word)\n'+seam) + namespace=dict(entry.__dict__);namespace['_native_trace']=native_trace + exec(compile(changed,str(package/'candidate.py'),'exec'),namespace) + qualify=namespace['qualify'] + def qualified(): + result=qualify() + require(len(captures)==1,'one complete actual native observation') + print(json.dumps(dict(status='PASS_COMPLETE_NATIVE_COVERAGE',actual=captures[0],build=native_backend.receipt(),native_finite_included=True,compiler_children_charged=True,integer_oracle_unchanged=True),sort_keys=True)) + return result + namespace['qualify']=qualified + namespace['main']() + +if __name__=='__main__': + require(len(sys.argv)==2 and sys.argv[1] in ('B','C'),'complete B or C') + main(sys.argv[1]=='C') diff --git a/research/fraction-native-qualification/full_B.py b/research/fraction-native-qualification/full_B.py new file mode 100644 index 0000000000..f22596d078 --- /dev/null +++ b/research/fraction-native-qualification/full_B.py @@ -0,0 +1,2 @@ +from full import main +main(False) diff --git a/research/fraction-native-qualification/full_C.py b/research/fraction-native-qualification/full_C.py new file mode 100644 index 0000000000..c6dc7a2dc5 --- /dev/null +++ b/research/fraction-native-qualification/full_C.py @@ -0,0 +1,2 @@ +from full import main +main(True) diff --git a/research/fraction-native-qualification/guard.py b/research/fraction-native-qualification/guard.py new file mode 100644 index 0000000000..bf4265b129 --- /dev/null +++ b/research/fraction-native-qualification/guard.py @@ -0,0 +1,120 @@ +"""Serial bounded Linux measurements; preserve the complete frozen precision contract.""" +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import platform +import signal +import statistics +import subprocess +import sys +import tempfile +import time + +HERE = Path(__file__).resolve().parent +SOURCE = HERE +CLOSURE = ('frozen.py','primitive_profile.py','guard.py','dispatch.py','inputs/PR5848.tar','../feasibility/fraction_table.py','../feasibility/finite.py','/usr/lib/python3.12/fractions.py','../feasibility/actual_audit.py') +TIMEOUT = 180 +RSS_CAP = 1024**3 +OUTPUT_CAP = 2*1024**2 +AGGREGATE = 600 +PREVIOUS_WALL_SECONDS = 0 + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + +def inventory(): + result = {} + for name in CLOSURE: + path = SOURCE / name + if path.is_symlink() or not path.is_file(): + raise ValueError('Regular complete runtime file: ' + name) + result[name] = [sha(path.read_bytes()), path.stat().st_mode & 0o777] + return result + +def group_rss(group): + total = 0 + count = 0 + for p in Path('/proc').iterdir(): + if not p.name.isdigit(): + continue + try: + raw = (p/'stat').read_text() + fields = raw[raw.rfind(')')+2:].split() + if int(fields[2]) == group: + total += int(fields[21])*os.sysconf('SC_PAGE_SIZE') + count += 1 + except (FileNotFoundError, ProcessLookupError, PermissionError): + pass + return total, count + +def run(label, script, optimized=False): + records = HERE/'runs' + records.mkdir(exist_ok=True) + prior = list(records.glob('*/receipt.json')) + spent = PREVIOUS_WALL_SECONDS + sum(json.loads(p.read_bytes())['wall_seconds'] for p in prior) + if spent >= AGGREGATE: + raise ValueError('Aggregate budget consumed') + folder = records/label + folder.mkdir() + before = inventory() + env = os.environ.copy() + for key in ('PYTHONPATH','PYTHONOPTIMIZE','PYTHONINSPECT','PYTHONSTARTUP','PYTHONPYCACHEPREFIX'): + env.pop(key,None) + env.update(PYTHONHASHSEED='0', LC_ALL='C.UTF-8', TZ='UTC') + usage = folder/'usage.json' + with tempfile.TemporaryDirectory(prefix='linux5757-bytecode-') as cache: + command = ['/usr/bin/python3.12', '-B', '-X', 'pycache_prefix='+cache] + if optimized: + command.append('-O') + command.append(str(SOURCE/script)) + timed = ['/usr/bin/time','-f','{"user_seconds":%U,"system_seconds":%S,"kernel_max_rss_kib":%M,"exit":%x}', '-o', str(usage),'--',*command] + start = time.monotonic() + peak = 0 + stop = None + with (folder/'stdout.txt').open('wb') as out, (folder/'stderr.txt').open('wb') as err: + p = subprocess.Popen(timed, cwd=SOURCE, env=env, stdout=out, stderr=err, start_new_session=True) + try: + while p.poll() is None: + rss, _ = group_rss(p.pid) + peak = max(peak,rss) + elapsed = time.monotonic()-start + if rss > RSS_CAP: + stop='sampled_group_rss_cap' + elif elapsed > min(TIMEOUT,AGGREGATE-spent): + stop='wall_or_aggregate_cap' + elif max((folder/'stdout.txt').stat().st_size,(folder/'stderr.txt').stat().st_size)>OUTPUT_CAP: + stop='output_cap' + if stop: + os.killpg(p.pid,signal.SIGKILL) + break + time.sleep(0.05) + code=p.wait() + finally: + try: os.killpg(p.pid,signal.SIGKILL) + except ProcessLookupError: pass + p.wait() + elapsed = time.monotonic()-start + stdout=(folder/'stdout.txt').read_bytes() + stderr=(folder/'stderr.txt').read_bytes() + after=inventory() + measurement=None + if usage.exists(): + try: measurement=json.loads(usage.read_bytes()) + except json.JSONDecodeError: measurement={'raw':usage.read_text()} + receipt={'label':label,'script':script,'optimized':optimized,'wall_seconds':elapsed, + 'exit':code,'termination':stop,'sampled_process_group_rss_bytes':peak, + 'usage':measurement,'stdout_sha256':sha(stdout),'stdout_bytes':len(stdout), + 'stderr_sha256':sha(stderr),'stderr_bytes':len(stderr), + 'source_inventory_sha256':sha(json.dumps(before,sort_keys=True,separators=(',',':')).encode()), + 'source_bytes_and_modes_unchanged':before==after, + 'python':sys.version,'platform':platform.platform(), + 'runner_sha256':sha(Path(__file__).read_bytes()),'runtime_policy_sha256':sha(json.dumps(CLOSURE).encode())} + receipt['status']='PASS' if code==0 and stop is None and not stderr and before==after else 'STOP' + (folder/'receipt.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + print(json.dumps(receipt,sort_keys=True),flush=True) + if receipt['status']!='PASS': + raise SystemExit(1) + return receipt diff --git a/research/fraction-native-qualification/micro.py b/research/fraction-native-qualification/micro.py new file mode 100644 index 0000000000..b5a33e039a --- /dev/null +++ b/research/fraction-native-qualification/micro.py @@ -0,0 +1,20 @@ +"""Fixed BCCB cache/loop screen, not a complete performance benchmark.""" +import json,time +from fractions import Fraction as F +import slot_parent +import fraction_table as table +import native_backend +from frozen import require + +def main(): + native_backend.load();weights=[(F(2),F(3)),(F(5),F(7))];tokens=[0,1] + results=[];count=65536 + for label,cls in [('B',slot_parent.CompactContributions),('C',table.CompactContributions),('C',table.CompactContributions),('B',slot_parent.CompactContributions)]: + c=cls(16384,weights,tokens);step=c.event(F(1));total=F(0) + cpu=time.process_time();wall=time.perf_counter() + for i in range(count):total+=step(F(0),F(i%4),i%2)[1] + results.append(dict(label=label,wall_seconds=time.perf_counter()-wall,cpu_seconds=time.process_time()-cpu,total=str(total),statistics=c.statistics())) + require(all(r['total']==results[0]['total'] and r['statistics']==results[0]['statistics'] for r in results),'all complete micro outputs/counters') + print(json.dumps(dict(status='PASS_NATIVE_MICRO_SCREEN_ONLY',fixed_order='BCCB',updates_per_arm=count,results=results,build=native_backend.receipt()),sort_keys=True)) + +if __name__=='__main__':main() diff --git a/research/fraction-native-qualification/micro_apply.py b/research/fraction-native-qualification/micro_apply.py new file mode 100644 index 0000000000..e1b06d8262 --- /dev/null +++ b/research/fraction-native-qualification/micro_apply.py @@ -0,0 +1,29 @@ +"""Fixed complete coefficient-loop comparison, separate from cache-only screen.""" +import json,time +from fractions import Fraction as F +import slot_parent +import fraction_table as table +import native_backend +from frozen import require + +native_backend.load();n=128;repetitions=512 +weights=[(F(i%5,4),F(i%7,8)) for i in range(n)];tokens=table.weight_tokens(weights) +src={i:F(i%5-2,2) for i in range(n)};old={i:F(i%3-1,4) for i in range(n)} +results=[] +for label in 'BCCB': + cls=slot_parent.CompactContributions if label=='B' else table.CompactContributions + c=cls(16384,weights,tokens);step=c.event(F(1,2));checksum=F(0) + cpu=time.process_time();wall=time.perf_counter() + for k in range(repetitions): + dst=dict(old);scores=[F(0),F(0),F(0)] + if label=='C':step.apply(dst,src,scores) + else: + for i,v in src.items(): + value,a,b,change=step(dst.get(i,F(0)),v,i) + scores[0]+=a;scores[1]+=b;scores[2]+=change + if value:dst[i]=value + else:dst.pop(i,None) + checksum+=scores[0]+scores[1]+scores[2] + results.append(dict(label=label,wall_seconds=time.perf_counter()-wall,cpu_seconds=time.process_time()-cpu,checksum=str(checksum),last_row={str(i):str(v) for i,v in dst.items()},last_scores=list(map(str,scores)),statistics=c.statistics())) +require(all({k:v for k,v in r.items() if k not in ('label','wall_seconds','cpu_seconds')}=={k:v for k,v in results[0].items() if k not in ('label','wall_seconds','cpu_seconds')} for r in results),'full apply micro equality/counters') +print(json.dumps(dict(status='PASS_NATIVE_APPLY_MICRO_ONLY',fixed_order='BCCB',updates_per_arm=n*repetitions,results=results,build=native_backend.receipt()),sort_keys=True)) diff --git a/research/fraction-native-qualification/native_backend.py b/research/fraction-native-qualification/native_backend.py new file mode 100644 index 0000000000..4ce062118c --- /dev/null +++ b/research/fraction-native-qualification/native_backend.py @@ -0,0 +1,61 @@ +"""Cold-build the owned C source; reuse code only within this process.""" +from hashlib import sha256 +import atexit +import importlib.util +import json +from pathlib import Path +import platform +import shutil +import subprocess +import sys +import sysconfig +import tempfile +import time + +HERE=Path(__file__).resolve().parent +_loaded=None +_temporary=None +_receipt=None + +def source_hash(): + path=HERE/'native_cache.c' + digest=sha256(path.read_bytes()).hexdigest() + expected=json.loads((HERE/'NATIVE-SOURCE.json').read_text())['sha256'] + if path.is_symlink() or digest!=expected:raise ValueError('exact owned C source') + return digest + +def load(): + global _loaded,_temporary,_receipt + digest=source_hash() + if _loaded is not None: + if _receipt['source_sha256']!=digest:raise ValueError('loaded native code has this exact source') + return _loaded + if platform.python_implementation()!='CPython' or sys.version_info[:2]!=(3,12) or sys.platform!='linux': + raise RuntimeError('native feasibility requires Linux CPython 3.12') + compiler=shutil.which('cc') + if not compiler:raise RuntimeError('native feasibility requires an existing C compiler') + start=time.perf_counter() + _temporary=tempfile.TemporaryDirectory(prefix='fraction-native-owned-') + atexit.register(_temporary.cleanup) + root=Path(_temporary.name) + raw=(HERE/'native_cache.c').read_bytes() + if sha256(raw).hexdigest()!=digest:raise ValueError('C source remained authenticated at snapshot') + snapshot=root/'native_cache.c';snapshot.write_bytes(raw);snapshot.chmod(0o444) + destination=root/('_fraction_native'+sysconfig.get_config_var('EXT_SUFFIX')) + flags=['-O2','-shared','-fPIC','-std=c11','-Wall','-Werror','-I'+sysconfig.get_path('include')] + command=[compiler,*flags,str(snapshot),'-o',str(destination)] + build=subprocess.run(command,capture_output=True,text=True,check=False) + if build.returncode or build.stderr or build.stdout: + raise RuntimeError('native build rejected: '+json.dumps(dict(command=command,returncode=build.returncode,stdout=build.stdout,stderr=build.stderr))) + destination.chmod(0o444) + spec=importlib.util.spec_from_file_location('_fraction_native',destination) + value=importlib.util.module_from_spec(spec);spec.loader.exec_module(value) + _receipt=dict(source_sha256=digest,compiler=compiler,flags=flags,SOABI=sysconfig.get_config_var('SOABI'), + extension_suffix=sysconfig.get_config_var('EXT_SUFFIX'),python=sys.version, + binary_sha256=sha256(destination.read_bytes()).hexdigest(),cold_build_load_wall_seconds=time.perf_counter()-start, + compiler_cpu_accounting='outer GNU time user+system includes compiler children', + compiler_version=subprocess.run([compiler,'--version'],capture_output=True,text=True,check=True).stdout.splitlines()[0]) + _loaded=value + return value + +def receipt():return None if _receipt is None else dict(_receipt) diff --git a/research/fraction-native-qualification/native_cache.c b/research/fraction-native-qualification/native_cache.c new file mode 100644 index 0000000000..ada7b0d0bf --- /dev/null +++ b/research/fraction-native-qualification/native_cache.c @@ -0,0 +1,227 @@ +/* Exact bounded cache/control only. All Fraction arithmetic stays in Python. + * Chris R / Clear1nsight, substantial OpenAI Codex/Astra assistance. Apache-2.0. + */ +#define PY_SSIZE_T_CLEAN +#include +#include + +typedef struct { + PyObject_HEAD + PyObject *dict, *weights, *tokens, *compute, *num, *den, *fraction; + PyObject **ring; + Py_ssize_t capacity, used, head, calls, hits, misses, evictions; + int ready, busy; +} Cache; +typedef struct { + PyObject_HEAD + vectorcallfunc vectorcall; + Cache *cache; + PyObject *q, *qn, *qd; +} Event; +static PyTypeObject CacheType, EventType; + +static int cache_traverse(Cache *s, visitproc visit, void *arg) { + Py_VISIT(s->dict); Py_VISIT(s->weights); Py_VISIT(s->tokens); + Py_VISIT(s->compute); Py_VISIT(s->num); Py_VISIT(s->den); Py_VISIT(s->fraction); + if (s->ring) for (Py_ssize_t i=0;icapacity;i++) Py_VISIT(s->ring[i]); + return 0; +} +static int cache_clear(Cache *s) { + s->ready=0; s->busy=1; + if (s->ring) { + for (Py_ssize_t i=0;icapacity;i++) Py_CLEAR(s->ring[i]); + PyMem_Free(s->ring); s->ring=NULL; + } + Py_CLEAR(s->dict); Py_CLEAR(s->weights); Py_CLEAR(s->tokens); + Py_CLEAR(s->compute); Py_CLEAR(s->num); Py_CLEAR(s->den); Py_CLEAR(s->fraction); + return 0; +} +static void cache_dealloc(Cache *s) { + PyObject_GC_UnTrack(s); cache_clear(s); Py_TYPE(s)->tp_free((PyObject *)s); +} +static int event_traverse(Event *s, visitproc visit, void *arg) { + Py_VISIT(s->cache); Py_VISIT(s->q); Py_VISIT(s->qn); Py_VISIT(s->qd); return 0; +} +static int event_clear(Event *s) { + Py_CLEAR(s->cache); Py_CLEAR(s->q); Py_CLEAR(s->qn); Py_CLEAR(s->qd); return 0; +} +static void event_dealloc(Event *s) { + PyObject_GC_UnTrack(s); event_clear(s); Py_TYPE(s)->tp_free((PyObject *)s); +} +static PyObject *event_disabled(PyTypeObject *type, PyObject *args, PyObject *kw) { + (void)type; (void)args; (void)kw; + PyErr_SetString(PyExc_TypeError,"events are created only by Cache.event"); return NULL; +} +static int is_pair(PyObject *p) { + return (PyList_CheckExact(p)||PyTuple_CheckExact(p)) && PySequence_Size(p)>=2; +} +static PyObject *cache_new(PyTypeObject *type, PyObject *args, PyObject *kw) { + if (kw && PyDict_Size(kw)) { PyErr_SetString(PyExc_TypeError,"positional cache arguments only");return NULL; } + PyObject *cap,*weights,*tokens,*compute,*num,*den,*fraction; + if (!PyArg_UnpackTuple(args,"Cache",7,7,&cap,&weights,&tokens,&compute,&num,&den,&fraction)) return NULL; + if (!PyLong_CheckExact(cap)) { PyErr_SetString(PyExc_ValueError,"integer capacity");return NULL; } + Py_ssize_t ncap=PyLong_AsSsize_t(cap); + if (ncap<1 || ncap>16384 || PyErr_Occurred()) { if(!PyErr_Occurred()) PyErr_SetString(PyExc_ValueError,"capacity 1..16384");return NULL; } + if (!(PyList_CheckExact(weights)||PyTuple_CheckExact(weights)) || !PyList_CheckExact(tokens) || !PyFunction_Check(compute) || !PyType_Check(fraction) || Py_TYPE(num)!=&PyMemberDescr_Type || Py_TYPE(den)!=&PyMemberDescr_Type || !Py_TYPE(num)->tp_descr_get || !Py_TYPE(den)->tp_descr_get) { + PyErr_SetString(PyExc_TypeError,"exact native packet types");return NULL; + } + Py_ssize_t n=PySequence_Size(weights); + if (PyList_GET_SIZE(tokens)!=n) { PyErr_SetString(PyExc_ValueError,"weight/token size");return NULL; } + Cache *s=(Cache *)type->tp_alloc(type,0); + if (!s) return NULL; + s->capacity=ncap; + s->dict=PyDict_New();s->weights=PyTuple_New(n);s->tokens=PyTuple_New(n); + s->ring=PyMem_Calloc((size_t)ncap,sizeof(PyObject *)); + if (!s->dict || !s->weights || !s->tokens || !s->ring) { if(!PyErr_Occurred())PyErr_NoMemory();Py_DECREF(s);return NULL; } + s->compute=Py_NewRef(compute);s->num=Py_NewRef(num);s->den=Py_NewRef(den);s->fraction=Py_NewRef(fraction); + for (Py_ssize_t i=0;iweights,i,pair); + PyObject *token=PySequence_GetItem(tokens,i); + if (!token) { Py_DECREF(s);return NULL; } + if (!PyLong_CheckExact(token)) { Py_DECREF(token);Py_DECREF(s);PyErr_SetString(PyExc_TypeError,"integer token");return NULL; } + Py_ssize_t t=PyLong_AsSsize_t(token); + if (t<0 || t>=16384 || PyErr_Occurred()) { Py_DECREF(token);Py_DECREF(s);if(!PyErr_Occurred())PyErr_SetString(PyExc_ValueError,"bounded token");return NULL; } + PyTuple_SET_ITEM(s->tokens,i,token); + } + s->ready=1;return (PyObject *)s; +} +static PyObject *member(PyObject *descriptor, PyObject *object, PyObject *type) { + return Py_TYPE(descriptor)->tp_descr_get(descriptor,object,type); +} +static PyObject *contribution(Event *e, PyObject *old, PyObject *v, Py_ssize_t i) { + Cache *s=e->cache; + if (i<0 || i>=PyTuple_GET_SIZE(s->tokens)) { PyErr_SetString(PyExc_IndexError,"native site index");return NULL; } + if (!Py_IS_TYPE(old,(PyTypeObject *)s->fraction)||!Py_IS_TYPE(v,(PyTypeObject *)s->fraction)) { PyErr_SetString(PyExc_TypeError,"exact Fraction coefficients");return NULL; } + PyObject *parts[4]={NULL,NULL,NULL,NULL}; + for (int k=0;k<4;k++) { + parts[k]=member(k%2?s->den:s->num,k<2?old:v,s->fraction); + if (!parts[k] || !PyLong_CheckExact(parts[k])) { + for(int j=0;j<4;j++)Py_XDECREF(parts[j]); + if(!PyErr_Occurred())PyErr_SetString(PyExc_TypeError,"integer Fraction slots"); + return NULL; + } + } + PyObject *key=PyTuple_New(7); + if(!key){for(int j=0;j<4;j++)Py_DECREF(parts[j]);return NULL;} + PyTuple_SET_ITEM(key,0,parts[0]);PyTuple_SET_ITEM(key,1,parts[1]); + PyTuple_SET_ITEM(key,2,Py_NewRef(e->qn));PyTuple_SET_ITEM(key,3,Py_NewRef(e->qd)); + PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i))); + if(s->calls==PY_SSIZE_T_MAX){Py_DECREF(key);PyErr_SetString(PyExc_OverflowError,"native counter overflow");return NULL;} + s->calls++; + PyObject *result=PyDict_GetItemWithError(s->dict,key); + if(result){s->hits++;Py_INCREF(result);Py_DECREF(key);return result;} + if(PyErr_Occurred()){Py_DECREF(key);return NULL;} + s->misses++; + PyObject *pair=PyTuple_GET_ITEM(s->weights,i); + PyObject *argv[5]={old,e->q,v,PyTuple_GET_ITEM(pair,0),PyTuple_GET_ITEM(pair,1)}; + result=PyObject_Vectorcall(s->compute,argv,5,NULL); + if(!result){Py_DECREF(key);return NULL;} + if(!PyTuple_CheckExact(result)||PyTuple_GET_SIZE(result)!=4){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,"four exact contributions");return NULL;} + for(int k=0;k<4;k++)if(!Py_IS_TYPE(PyTuple_GET_ITEM(result,k),(PyTypeObject *)s->fraction)){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,"Fraction contributions");return NULL;} + if(s->used==s->capacity){ + PyObject *oldkey=s->ring[s->head]; + if(PyDict_DelItem(s->dict,oldkey)<0){Py_DECREF(result);Py_DECREF(key);return NULL;} + Py_CLEAR(s->ring[s->head]);s->used--;s->evictions++; + } + if(PyDict_SetItem(s->dict,key,result)<0){Py_DECREF(result);Py_DECREF(key);return NULL;} + s->ring[s->head]=key;s->head=(s->head+1)%s->capacity;s->used++; + return result; +} +static int begin_event(Event *e) { + if(!e->cache||!e->cache->ready){PyErr_SetString(PyExc_RuntimeError,"cleared native event");return -1;} + if(e->cache->busy){PyErr_SetString(PyExc_RuntimeError,"reentrant native event");return -1;} + e->cache->busy=1;return 0; +} +static PyObject *event_call(PyObject *obj, PyObject *const *args, size_t nargsf, PyObject *kw) { + Event *e=(Event *)obj; + if(PyVectorcall_NARGS(nargsf)!=3 || (kw&&PyTuple_GET_SIZE(kw))){PyErr_SetString(PyExc_TypeError,"event(old,v,index)");return NULL;} + if(!PyLong_CheckExact(args[2])){PyErr_SetString(PyExc_TypeError,"integer site index");return NULL;} + Py_ssize_t i=PyLong_AsSsize_t(args[2]);if(PyErr_Occurred())return NULL; + if(begin_event(e)<0)return NULL; + PyObject *result=contribution(e,args[0],args[1],i);e->cache->busy=0;return result; +} +static PyObject *cache_event(Cache *s, PyObject *q) { + if(!s->ready){PyErr_SetString(PyExc_RuntimeError,"cleared cache");return NULL;} + if(!Py_IS_TYPE(q,(PyTypeObject *)s->fraction)){PyErr_SetString(PyExc_TypeError,"exact Fraction scalar");return NULL;} + Event *e=(Event *)EventType.tp_alloc(&EventType,0);if(!e)return NULL; + e->vectorcall=event_call;e->cache=(Cache *)Py_NewRef((PyObject *)s);e->q=Py_NewRef(q); + e->qn=member(s->num,q,s->fraction); + if(!e->qn){Py_DECREF(e);return NULL;} + e->qd=member(s->den,q,s->fraction); + if(!e->qd){Py_DECREF(e);return NULL;} + if(!PyLong_CheckExact(e->qn)||!PyLong_CheckExact(e->qd)){Py_DECREF(e);PyErr_SetString(PyExc_TypeError,"integer scalar slots");return NULL;} + return (PyObject *)e; +} +static PyObject *cache_statistics(Cache *s, PyObject *unused) { + (void)unused; + if(!s->ready){PyErr_SetString(PyExc_RuntimeError,"cleared cache");return NULL;} + return Py_BuildValue("{s:n,s:n,s:n,s:n,s:n,s:n,s:n}","calls",s->calls,"hits",s->hits,"misses",s->misses,"evictions",s->evictions,"bypasses",(Py_ssize_t)0,"resident",PyDict_Size(s->dict),"capacity",s->capacity); +} +static PyObject *event_apply(Event *e, PyObject *args) { + PyObject *dst,*src,*scores; + if(!PyArg_UnpackTuple(args,"apply",3,3,&dst,&src,&scores))return NULL; + if(!PyDict_CheckExact(dst)||!PyDict_CheckExact(src)||dst==src||!PyList_CheckExact(scores)||PyList_GET_SIZE(scores)!=3){PyErr_SetString(PyExc_TypeError,"distinct exact rows and three scores");return NULL;} + if(begin_event(e)<0)return NULL; + Cache *s=e->cache; + PyObject *pair=NULL,*result=NULL; + PyObject *view=PyObject_CallMethod(src,"items",NULL); + PyObject *iterator=view?PyObject_GetIter(view):NULL; + Py_XDECREF(view); + if(!iterator)goto fail; + while((pair=PyIter_Next(iterator))){ + if(!PyTuple_CheckExact(pair)||PyTuple_GET_SIZE(pair)!=2){PyErr_SetString(PyExc_TypeError,"dict item pair");goto fail;} + PyObject *index=PyTuple_GET_ITEM(pair,0),*value=PyTuple_GET_ITEM(pair,1); + if(!PyLong_CheckExact(index)){PyErr_SetString(PyExc_TypeError,"integer source site");goto fail;} + Py_ssize_t i=PyLong_AsSsize_t(index);if(PyErr_Occurred())goto fail; + PyObject *zeroarg=PyLong_FromLong(0);if(!zeroarg)goto fail; + PyObject *zero=PyObject_CallOneArg(s->fraction,zeroarg);Py_DECREF(zeroarg);if(!zero)goto fail; + PyObject *old=PyDict_GetItemWithError(dst,index); + if(old){Py_INCREF(old);Py_DECREF(zero);}else if(PyErr_Occurred()){Py_DECREF(zero);goto fail;}else old=zero; + result=contribution(e,old,value,i);Py_DECREF(old);if(!result)goto fail; + for(int k=0;k<3;k++){ + PyObject *score=PyList_GetItem(scores,k); + if(!score)goto fail; + Py_INCREF(score); + PyObject *next=PyNumber_InPlaceAdd(score,PyTuple_GET_ITEM(result,k+1)); + Py_DECREF(score); + if(!next)goto fail; + if(PyList_SetItem(scores,k,next)<0)goto fail; + } + int truth=PyObject_IsTrue(PyTuple_GET_ITEM(result,0)); + if(truth<0)goto fail; + if(truth){if(PyDict_SetItem(dst,index,PyTuple_GET_ITEM(result,0))<0)goto fail;} + else{ + PyObject *present=PyDict_GetItemWithError(dst,index); + if(present){if(PyDict_DelItem(dst,index)<0)goto fail;} + else if(PyErr_Occurred())goto fail; + } + Py_CLEAR(result);Py_CLEAR(pair); + } + if(PyErr_Occurred())goto fail; + Py_DECREF(iterator);s->busy=0;Py_RETURN_NONE; +fail:Py_XDECREF(result);Py_XDECREF(pair);Py_XDECREF(iterator);s->busy=0;return NULL; +} +static PyMethodDef cache_methods[]={{"event",(PyCFunction)cache_event,METH_O,"Fresh scalar context."},{"statistics",(PyCFunction)cache_statistics,METH_NOARGS,"Full counters."},{NULL,NULL,0,NULL}}; +static PyMethodDef event_methods[]={{"apply",(PyCFunction)event_apply,METH_VARARGS,"Same coefficient loop and Python numeric operations."},{NULL,NULL,0,NULL}}; +static PyTypeObject CacheType={PyVarObject_HEAD_INIT(NULL,0) + .tp_name="_fraction_native.Cache",.tp_basicsize=sizeof(Cache),.tp_flags=Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC, + .tp_new=cache_new,.tp_dealloc=(destructor)cache_dealloc,.tp_traverse=(traverseproc)cache_traverse,.tp_clear=(inquiry)cache_clear,.tp_methods=cache_methods}; +static PyTypeObject EventType={PyVarObject_HEAD_INIT(NULL,0) + .tp_name="_fraction_native.Event",.tp_basicsize=sizeof(Event),.tp_flags=Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_VECTORCALL, + .tp_new=event_disabled,.tp_dealloc=(destructor)event_dealloc,.tp_traverse=(traverseproc)event_traverse,.tp_clear=(inquiry)event_clear, + .tp_call=PyVectorcall_Call,.tp_vectorcall_offset=offsetof(Event,vectorcall),.tp_methods=event_methods}; +static struct PyModuleDef module={PyModuleDef_HEAD_INIT,"_fraction_native","Bounded cache; exact Python arithmetic.",-1,NULL}; +PyMODINIT_FUNC PyInit__fraction_native(void){ + if(PyType_Ready(&CacheType)<0||PyType_Ready(&EventType)<0)return NULL; + PyObject *m=PyModule_Create(&module);if(!m)return NULL; + if(PyModule_AddObjectRef(m,"Cache",(PyObject *)&CacheType)<0){Py_DECREF(m);return NULL;} + return m; +} diff --git a/research/fraction-native-qualification/replay.py b/research/fraction-native-qualification/replay.py new file mode 100644 index 0000000000..e7a41b6f40 --- /dev/null +++ b/research/fraction-native-qualification/replay.py @@ -0,0 +1,13 @@ +"""Guarded explicit complete replay, with retained external evidence.""" +import json,sys +from pathlib import Path +import guard +if len(sys.argv)!=2:raise ValueError('Supply one external evidence directory') +package=Path(__file__).resolve().parent;output=Path(sys.argv[1]).resolve() +if output.is_relative_to(package):raise ValueError('Evidence stays outside the immutable package') +output.mkdir(parents=True,exist_ok=True) +guard.SOURCE=package;guard.HERE=output +guard.CLOSURE=tuple(sorted(str(p.relative_to(package)) for p in package.rglob('*') if p.is_file() and '__pycache__' not in p.parts))+('/usr/lib/python3.12/fractions.py',) +with (output/'execution.lock').open('a') as lock: + guard.fcntl.flock(lock,guard.fcntl.LOCK_EX|guard.fcntl.LOCK_NB) + guard.run('complete-native','replay_driver.py') diff --git a/research/fraction-native-qualification/replay_driver.py b/research/fraction-native-qualification/replay_driver.py new file mode 100644 index 0000000000..9a1f086f01 --- /dev/null +++ b/research/fraction-native-qualification/replay_driver.py @@ -0,0 +1,9 @@ +"""Explicit complete replay; includes all new checks and a cold native build.""" +import sys +from frozen import require +import custody +from full import main +if __name__=='__main__': + require(len(sys.argv)==1,'No replay arguments') + custody.main() + main(True) diff --git a/research/fraction-native-qualification/verify.py b/research/fraction-native-qualification/verify.py new file mode 100644 index 0000000000..35930ff9ea --- /dev/null +++ b/research/fraction-native-qualification/verify.py @@ -0,0 +1,14 @@ +"""Fresh registered finite/native/source-custody verification, not timing admission.""" +import json,sys +from pathlib import Path +from frozen import require +import custody +from finite import main + +if __name__=='__main__': + require(len(sys.argv)==1,'No registered verifier arguments') + custody.main() + result=main();build=result.pop('build') + require(result==json.loads(Path(__file__).with_name('RESULT.json').read_text()),'all inherited/native finite outputs and controls') + require(build['source_sha256']==json.loads(Path(__file__).with_name('NATIVE-SOURCE.json').read_text())['sha256'],'native build source authenticated') + print('PASS_FRACTION_NATIVE_FINITE_AND_CUSTODY') From 3f15c943e4ad6479f03e674c80fff1269a16ccfe Mon Sep 17 00:00:00 2001 From: d3lerium Date: Tue, 27 Oct 2026 20:22:24 +1100 Subject: [PATCH 4/4] Retain passing readonly Git-free full native qualification evidence --- .../VALIDATION.json | 35 ++++++++++++++++++- .../evidence/SEALED-RESULT.json | 33 +++++++++++++++++ .../runs/complete-native/receipt.json | 26 ++++++++++++++ .../portable/runs/complete-native/stderr.txt | 0 .../portable/runs/complete-native/stdout.txt | 10 ++++++ .../portable/runs/complete-native/usage.json | 1 + 6 files changed, 104 insertions(+), 1 deletion(-) create mode 100644 research/fraction-native-qualification/evidence/SEALED-RESULT.json create mode 100644 research/fraction-native-qualification/evidence/portable/runs/complete-native/receipt.json create mode 100644 research/fraction-native-qualification/evidence/portable/runs/complete-native/stderr.txt create mode 100644 research/fraction-native-qualification/evidence/portable/runs/complete-native/stdout.txt create mode 100644 research/fraction-native-qualification/evidence/portable/runs/complete-native/usage.json diff --git a/research/fraction-native-qualification/VALIDATION.json b/research/fraction-native-qualification/VALIDATION.json index f8d372ac05..545178cce1 100644 --- a/research/fraction-native-qualification/VALIDATION.json +++ b/research/fraction-native-qualification/VALIDATION.json @@ -68,5 +68,38 @@ "independent_human_or_kernel_acceptance": false, "hosted_performance": false, "scope": "Only frozen PR5848; no kappa, physical/cost/compiler or selected-frontier change. Four predecessor custody controls are separate registered checks, as in PR5848, and excluded from both timed candidate.py stages.", - "packaged_registered_finite_normal_and_optimized": "PASS, including all four unchanged custody controls; receipts in evidence/runtime/runs" + "packaged_registered_finite_normal_and_optimized": "PASS, including all four unchanged custody controls; receipts in evidence/runtime/runs", + "portable_readonly_full_replay": { + "source_before_after_equal": true, + "files": 159, + "no_symlinks": true, + "run": { + "exit": 0, + "label": "complete-native", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "7d7c27fb5be89dfb6679036aa8c76a2d907465aa4bd21e242b2a0a70e5be7b3c", + "sampled_process_group_rss_bytes": 115798016, + "script": "replay_driver.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "67d631ee4df8aa3057fd6b61fa0c0575858524b752f4689d01fe4132b0b9a7c2", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14301, + "stdout_sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111632, + "system_seconds": 0.2, + "user_seconds": 32.74 + }, + "wall_seconds": 33.032243947003735 + }, + "git_free": true, + "source_commit": "8f04865e903eead8730be622357e3604c6fea179" + } } diff --git a/research/fraction-native-qualification/evidence/SEALED-RESULT.json b/research/fraction-native-qualification/evidence/SEALED-RESULT.json new file mode 100644 index 0000000000..0a3724b924 --- /dev/null +++ b/research/fraction-native-qualification/evidence/SEALED-RESULT.json @@ -0,0 +1,33 @@ +{ + "source_before_after_equal": true, + "files": 159, + "no_symlinks": true, + "run": { + "exit": 0, + "label": "complete-native", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "7d7c27fb5be89dfb6679036aa8c76a2d907465aa4bd21e242b2a0a70e5be7b3c", + "sampled_process_group_rss_bytes": 115798016, + "script": "replay_driver.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "67d631ee4df8aa3057fd6b61fa0c0575858524b752f4689d01fe4132b0b9a7c2", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14301, + "stdout_sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111632, + "system_seconds": 0.2, + "user_seconds": 32.74 + }, + "wall_seconds": 33.032243947003735 + }, + "git_free": true, + "source_commit": "8f04865e903eead8730be622357e3604c6fea179" +} diff --git a/research/fraction-native-qualification/evidence/portable/runs/complete-native/receipt.json b/research/fraction-native-qualification/evidence/portable/runs/complete-native/receipt.json new file mode 100644 index 0000000000..590be8e622 --- /dev/null +++ b/research/fraction-native-qualification/evidence/portable/runs/complete-native/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "complete-native", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "7d7c27fb5be89dfb6679036aa8c76a2d907465aa4bd21e242b2a0a70e5be7b3c", + "sampled_process_group_rss_bytes": 115798016, + "script": "replay_driver.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "67d631ee4df8aa3057fd6b61fa0c0575858524b752f4689d01fe4132b0b9a7c2", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14301, + "stdout_sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111632, + "system_seconds": 0.2, + "user_seconds": 32.74 + }, + "wall_seconds": 33.032243947003735 +} diff --git a/research/fraction-native-qualification/evidence/portable/runs/complete-native/stderr.txt b/research/fraction-native-qualification/evidence/portable/runs/complete-native/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/fraction-native-qualification/evidence/portable/runs/complete-native/stdout.txt b/research/fraction-native-qualification/evidence/portable/runs/complete-native/stdout.txt new file mode 100644 index 0000000000..9be7f66daf --- /dev/null +++ b/research/fraction-native-qualification/evidence/portable/runs/complete-native/stdout.txt @@ -0,0 +1,10 @@ +PASS_PRECISION_LINUX_SOURCE_CONTROLS {"contract": "declared contract edits", "declared_edit": "unique backend seam", "inner_archive": "source hash", "official_export_byte": "Exact PR5831 bundle"} +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "396549b0d3ce74ef0cc931adf70be92fe18a34d509ac6dfc6ab692622a04c9d8", "cold_build_load_wall_seconds": 0.30989734499598853, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "396549b0d3ce74ef0cc931adf70be92fe18a34d509ac6dfc6ab692622a04c9d8", "cold_build_load_wall_seconds": 0.30989734499598853, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 30.282628} diff --git a/research/fraction-native-qualification/evidence/portable/runs/complete-native/usage.json b/research/fraction-native-qualification/evidence/portable/runs/complete-native/usage.json new file mode 100644 index 0000000000..877681e80d --- /dev/null +++ b/research/fraction-native-qualification/evidence/portable/runs/complete-native/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.74,"system_seconds":0.20,"kernel_max_rss_kib":111632,"exit":0}