| """Stdlib tests for the OracleMem exact-small MVP.""" | |
| from __future__ import annotations | |
| import json | |
| import tempfile | |
| import unittest | |
| from pathlib import Path | |
| from oraclemem import evaluate | |
| class OracleMemEvaluationTests(unittest.TestCase): | |
| def test_exact_solver_matches_bruteforce(self) -> None: | |
| instance = evaluate.generate_synthetic_instance(11, normal_count=2, update_count=1) | |
| for budget in (3, 5, 8): | |
| exact = evaluate.exact_solve(instance, budget) | |
| brute = evaluate.brute_force_solve(instance, budget) | |
| self.assertAlmostEqual(exact.objective_value, brute.objective_value, places=9) | |
| self.assertTrue( | |
| evaluate.is_feasible(instance.candidates, exact.selected_candidate_ids, budget) | |
| ) | |
| def test_budget_and_group_feasibility_for_all_methods(self) -> None: | |
| instance = evaluate.generate_synthetic_instance(3, normal_count=2, update_count=1) | |
| rows = evaluate.evaluate_instance(instance, budgets=(3, 5, 7)) | |
| self.assertGreater(len(rows), 0) | |
| for row in rows: | |
| self.assertTrue(row.budget_feasible, row.to_json()) | |
| self.assertTrue(row.group_feasible, row.to_json()) | |
| self.assertLessEqual(row.selected_cost, row.budget) | |
| def test_ratio_labels_are_exact_and_not_reference_denominators(self) -> None: | |
| instance = evaluate.generate_synthetic_instance(5, normal_count=2, update_count=1) | |
| rows = evaluate.evaluate_instance( | |
| instance, budgets=(4,), methods=("opt", "oracle_gvt", "greedy") | |
| ) | |
| for row in rows: | |
| self.assertEqual(row.denominator_label, "exact_opt") | |
| self.assertEqual(row.upper_bound_source, "exact_opt") | |
| self.assertIsNotNone(row.ratio_to_opt) | |
| self.assertIsNotNone(row.ratio_to_upper_bound) | |
| self.assertLessEqual(row.ratio_to_opt or 0.0, 1.0 + 1e-9) | |
| if row.method == "opt": | |
| self.assertAlmostEqual(row.ratio_to_opt or 0.0, 1.0) | |
| summary = evaluate.aggregate_results(rows) | |
| labels = summary["label_definitions"] | |
| self.assertIn("exact optimum is certified", labels["ratio_to_opt"]) | |
| self.assertIn("never labeled as OPT", labels["ratio_to_reference"]) | |
| def test_tombstone_benefit_on_update_stream(self) -> None: | |
| instance = evaluate.make_update_stress_instance() | |
| rows = evaluate.evaluate_instance( | |
| instance, | |
| budgets=(3,), | |
| methods=("oracle_gvt", "no_tombstone_gvt", "no_tombstone_opt", "fact_only"), | |
| ) | |
| by_method = {row.method: row for row in rows} | |
| aware = by_method["oracle_gvt"] | |
| no_tombstone = by_method["no_tombstone_gvt"] | |
| no_tombstone_opt = by_method["no_tombstone_opt"] | |
| fact_only = by_method["fact_only"] | |
| self.assertGreater(aware.objective_value, no_tombstone.objective_value) | |
| self.assertGreater(aware.objective_value, no_tombstone_opt.objective_value) | |
| self.assertGreater(aware.objective_value, fact_only.objective_value) | |
| self.assertEqual(aware.update_metrics["invalidation_units_covered"], 1.0) | |
| self.assertEqual(no_tombstone.update_metrics["invalidation_units_covered"], 0.0) | |
| self.assertEqual(no_tombstone_opt.update_metrics["invalidation_units_covered"], 0.0) | |
| self.assertGreater(aware.update_metrics["selected_tombstone_like"], 0.0) | |
| def test_estimated_methods_use_estimates_not_oracle_marginals(self) -> None: | |
| instance = evaluate.OracleMemInstance( | |
| "estimated_policy_fixture", | |
| ( | |
| evaluate.CandidateMemory( | |
| "oracle_best", | |
| "exp0", | |
| "atomic_fact", | |
| "FACT hidden gold evidence", | |
| 1, | |
| {"gold": 1.0}, | |
| estimated_value=0.1, | |
| estimator_model="fixture", | |
| ), | |
| evaluate.CandidateMemory( | |
| "estimated_best", | |
| "exp0", | |
| "summary", | |
| "SUMMARY visibly important but actually weak", | |
| 1, | |
| {"gold": 0.0}, | |
| estimated_value=5.0, | |
| estimator_model="fixture", | |
| ), | |
| ), | |
| {"gold": 1.0}, | |
| current_units=("gold",), | |
| ) | |
| rows = evaluate.evaluate_instance( | |
| instance, | |
| budgets=(1,), | |
| methods=("oracle_gvt", "estimated_gvt", "estimated_utility"), | |
| estimator_model=evaluate.DEFAULT_ESTIMATOR_MODEL, | |
| estimator_profile="external", | |
| ) | |
| by_method = {row.method: row for row in rows} | |
| self.assertEqual(by_method["oracle_gvt"].selected_candidate_ids, ("oracle_best",)) | |
| self.assertEqual(by_method["estimated_gvt"].selected_candidate_ids, ("estimated_best",)) | |
| self.assertEqual( | |
| by_method["estimated_utility"].selected_candidate_ids, | |
| ("estimated_best",), | |
| ) | |
| self.assertLess(by_method["estimated_gvt"].objective_value, by_method["oracle_gvt"].objective_value) | |
| self.assertEqual( | |
| by_method["estimated_gvt"].policy_metadata["estimator_model"], | |
| evaluate.DEFAULT_ESTIMATOR_MODEL, | |
| ) | |
| self.assertFalse(by_method["estimated_gvt"].policy_metadata["api_called"]) | |
| def test_estimated_methods_run_on_stress_distribution(self) -> None: | |
| rows = evaluate.run_synthetic_benchmark( | |
| seeds=(0, 1), | |
| budgets=(4,), | |
| distributions=("scope_shift_v2",), | |
| methods=("estimated_gvt", "estimated_utility"), | |
| estimator_model=evaluate.DEFAULT_ESTIMATOR_MODEL, | |
| ) | |
| self.assertEqual(len(rows), 4) | |
| for row in rows: | |
| self.assertTrue(row.budget_feasible, row.to_json()) | |
| self.assertTrue(row.group_feasible, row.to_json()) | |
| self.assertEqual( | |
| row.policy_metadata["estimator_model"], | |
| evaluate.DEFAULT_ESTIMATOR_MODEL, | |
| ) | |
| self.assertEqual(row.policy_metadata["estimator_profile"], "gemini_flash_lite_v1") | |
| def test_noisy_estimator_profile_is_local_and_supported(self) -> None: | |
| rows = evaluate.run_synthetic_benchmark( | |
| seeds=(0,), | |
| budgets=(4,), | |
| distributions=("scope_shift_v2",), | |
| methods=("estimated_gvt", "estimated_utility"), | |
| estimator_model=evaluate.DEFAULT_ESTIMATOR_MODEL, | |
| estimator_profile=evaluate.NOISY_ESTIMATOR_PROFILE, | |
| ) | |
| self.assertEqual(len(rows), 2) | |
| for row in rows: | |
| self.assertTrue(row.budget_feasible, row.to_json()) | |
| self.assertTrue(row.group_feasible, row.to_json()) | |
| self.assertEqual(row.policy_metadata["estimator_profile"], evaluate.NOISY_ESTIMATOR_PROFILE) | |
| self.assertFalse(row.policy_metadata["api_called"]) | |
| def test_train_dev_estimator_uses_visible_features_not_dev_oracle(self) -> None: | |
| train_instance = evaluate.OracleMemInstance( | |
| "learned_train_fixture", | |
| ( | |
| evaluate.CandidateMemory( | |
| "train_update_good", | |
| "train_update", | |
| "compound_update", | |
| "UPDATE corrected current preference with explicit invalidation", | |
| 1, | |
| {"train_gold": 1.0}, | |
| ), | |
| evaluate.CandidateMemory( | |
| "train_fact_weak", | |
| "train_fact", | |
| "atomic_fact", | |
| "FACT weak standalone note", | |
| 1, | |
| {"train_weak": 0.05}, | |
| ), | |
| ), | |
| {"train_gold": 4.0, "train_weak": 1.0}, | |
| ) | |
| estimator = evaluate.train_feature_utility_estimator( | |
| (train_instance,), | |
| train_distributions=("fixture",), | |
| train_seeds=(0,), | |
| ridge=0.01, | |
| ) | |
| dev_instance = evaluate.OracleMemInstance( | |
| "learned_dev_fixture", | |
| ( | |
| evaluate.CandidateMemory( | |
| "oracle_best", | |
| "dev_exp", | |
| "atomic_fact", | |
| "FACT hidden gold evidence", | |
| 1, | |
| {"gold": 1.0}, | |
| ), | |
| evaluate.CandidateMemory( | |
| "learned_visible", | |
| "dev_exp", | |
| "compound_update", | |
| "UPDATE corrected current preference with explicit invalidation", | |
| 1, | |
| {}, | |
| ), | |
| ), | |
| {"gold": 1.0}, | |
| current_units=("gold",), | |
| ) | |
| rows = evaluate.evaluate_instance( | |
| dev_instance, | |
| budgets=(1,), | |
| methods=("oracle_gvt", "estimated_gvt", "estimated_utility"), | |
| estimator_model=estimator.estimator_model, | |
| estimator_profile=evaluate.LEARNED_ESTIMATOR_PROFILE, | |
| estimator_state=estimator, | |
| ) | |
| by_method = {row.method: row for row in rows} | |
| self.assertEqual(by_method["oracle_gvt"].selected_candidate_ids, ("oracle_best",)) | |
| self.assertEqual(by_method["estimated_gvt"].selected_candidate_ids, ("learned_visible",)) | |
| self.assertEqual(by_method["estimated_utility"].selected_candidate_ids, ("learned_visible",)) | |
| self.assertLess(by_method["estimated_gvt"].objective_value, by_method["oracle_gvt"].objective_value) | |
| metadata = by_method["estimated_gvt"].policy_metadata | |
| self.assertEqual(metadata["estimator_profile"], evaluate.LEARNED_ESTIMATOR_PROFILE) | |
| self.assertFalse(metadata["api_called"]) | |
| self.assertTrue(metadata["trained_estimator"]) | |
| self.assertTrue(metadata["oracle_coverage_used_for_training"]) | |
| self.assertFalse(metadata["oracle_coverage_used_for_dev_decision"]) | |
| def test_synthetic_train_dev_benchmark_evaluates_only_dev_seeds(self) -> None: | |
| rows = evaluate.run_synthetic_train_dev_benchmark( | |
| train_seeds=(0, 1), | |
| dev_seeds=(2, 3), | |
| budgets=(4,), | |
| distributions=("base",), | |
| methods=("estimated_gvt", "estimated_utility"), | |
| normal_count=1, | |
| update_count=1, | |
| estimator_ridge=0.1, | |
| ) | |
| self.assertEqual(len(rows), 4) | |
| self.assertEqual({row.seed for row in rows}, {2, 3}) | |
| for row in rows: | |
| self.assertTrue(row.budget_feasible, row.to_json()) | |
| self.assertTrue(row.group_feasible, row.to_json()) | |
| self.assertEqual(row.policy_metadata["estimator_profile"], evaluate.LEARNED_ESTIMATOR_PROFILE) | |
| self.assertEqual(row.policy_metadata["train_seeds"], [0, 1]) | |
| self.assertFalse(row.policy_metadata["oracle_coverage_used_for_dev_decision"]) | |
| def test_human_package_evaluator_accepts_trained_estimator(self) -> None: | |
| from llm_memory_validation.evaluate_human_style_examples import evaluate_human_package | |
| train_instance = evaluate.OracleMemInstance( | |
| "human_learned_train_fixture", | |
| ( | |
| evaluate.CandidateMemory( | |
| "train_visible_good", | |
| "train_exp", | |
| "compound_update", | |
| "UPDATE corrected current preference with explicit invalidation", | |
| 1, | |
| {"train_gold": 1.0}, | |
| ), | |
| evaluate.CandidateMemory( | |
| "train_weak", | |
| "train_weak_exp", | |
| "summary", | |
| "short low-signal summary", | |
| 1, | |
| {"train_weak": 0.01}, | |
| ), | |
| ), | |
| {"train_gold": 3.0, "train_weak": 1.0}, | |
| ) | |
| estimator = evaluate.train_feature_utility_estimator( | |
| (train_instance,), | |
| train_distributions=("fixture",), | |
| train_seeds=(0,), | |
| ridge=0.01, | |
| ) | |
| heldout_instance = evaluate.OracleMemInstance( | |
| "human_learned_heldout_fixture", | |
| ( | |
| evaluate.CandidateMemory( | |
| "oracle_best", | |
| "heldout_exp", | |
| "atomic_fact", | |
| "FACT hidden gold evidence", | |
| 1, | |
| {"gold": 1.0}, | |
| ), | |
| evaluate.CandidateMemory( | |
| "learned_visible", | |
| "heldout_exp", | |
| "compound_update", | |
| "UPDATE corrected current preference with explicit invalidation", | |
| 1, | |
| {}, | |
| ), | |
| ), | |
| {"gold": 1.0}, | |
| current_units=("gold",), | |
| ) | |
| rows = evaluate_human_package( | |
| heldout_instance, | |
| budgets=(1,), | |
| methods=("opt", "oracle_gvt", "estimated_gvt", "estimated_utility"), | |
| estimator_model=estimator.estimator_model, | |
| estimator_profile=evaluate.LEARNED_ESTIMATOR_PROFILE, | |
| estimator_state=estimator, | |
| ) | |
| by_method = {row.method: row for row in rows} | |
| self.assertEqual(by_method["opt"].selected_candidate_ids, ("oracle_best",)) | |
| self.assertEqual(by_method["oracle_gvt"].selected_candidate_ids, ("oracle_best",)) | |
| self.assertEqual(by_method["estimated_gvt"].selected_candidate_ids, ("learned_visible",)) | |
| self.assertEqual(by_method["estimated_utility"].selected_candidate_ids, ("learned_visible",)) | |
| metadata = by_method["estimated_gvt"].policy_metadata | |
| self.assertTrue(metadata["trained_estimator"]) | |
| self.assertTrue(metadata["oracle_coverage_used_for_training"]) | |
| self.assertFalse(metadata["oracle_coverage_used_for_dev_decision"]) | |
| def test_method_comparisons_are_nondegenerate(self) -> None: | |
| instance = evaluate.generate_synthetic_instance(7, normal_count=3, update_count=2) | |
| rows = evaluate.evaluate_instance(instance, budgets=(4,), methods=evaluate.DEFAULT_METHODS) | |
| values = {row.method: round(row.objective_value, 8) for row in rows} | |
| self.assertGreaterEqual(len(set(values.values())), 3, values) | |
| opt_value = values["opt"] | |
| for method, value in values.items(): | |
| self.assertLessEqual(value, opt_value + 1e-8, method) | |
| self.assertLess(values["recency_raw"], opt_value) | |
| self.assertIn("reservoir_raw", values) | |
| def test_deployable_writer_baselines_are_feasible(self) -> None: | |
| instance = evaluate.generate_synthetic_instance(9, normal_count=3, update_count=2) | |
| rows = evaluate.evaluate_instance( | |
| instance, | |
| budgets=(5,), | |
| methods=("memgpt_tiered", "mem0_extract", "amem_graph", "amac_admission"), | |
| ) | |
| self.assertEqual( | |
| {row.method for row in rows}, | |
| {"memgpt_tiered", "mem0_extract", "amem_graph", "amac_admission"}, | |
| ) | |
| for row in rows: | |
| self.assertTrue(row.budget_feasible, row.to_json()) | |
| self.assertTrue(row.group_feasible, row.to_json()) | |
| self.assertLessEqual(row.selected_cost, row.budget) | |
| self.assertEqual( | |
| row.policy_metadata.get("policy_family"), | |
| "deployable_writer_baseline", | |
| ) | |
| self.assertFalse(row.policy_metadata.get("external_service_dependencies")) | |
| self.assertFalse(row.policy_metadata.get("oracle_coverage_used_for_decision")) | |
| self.assertIn("proxy_for", row.policy_metadata) | |
| self.assertRegex( | |
| row.policy_metadata.get("limitation", ""), | |
| r"(Local proxy only|Faithful local adapter only)", | |
| ) | |
| def test_candidate_quality_ablations_use_filtered_candidate_pools(self) -> None: | |
| instance = evaluate.generate_synthetic_instance(10, normal_count=3, update_count=2) | |
| rows = evaluate.evaluate_instance( | |
| instance, | |
| budgets=(6,), | |
| methods=("opt", "generic_candidate_opt", "generic_candidate_gvt", "summary_candidate_opt"), | |
| ) | |
| by_method = {row.method: row for row in rows} | |
| by_id = evaluate.candidates_by_id(instance.candidates) | |
| opt_value = by_method["opt"].objective_value | |
| for method in ("generic_candidate_opt", "generic_candidate_gvt", "summary_candidate_opt"): | |
| self.assertLessEqual(by_method[method].objective_value, opt_value + 1e-8) | |
| self.assertEqual( | |
| by_method[method].policy_metadata.get("policy_family"), | |
| "candidate_quality_ablation", | |
| ) | |
| for candidate_id in by_method["generic_candidate_opt"].selected_candidate_ids: | |
| self.assertIn( | |
| by_id[candidate_id].representation_type, | |
| evaluate.GENERIC_CANDIDATE_TYPES, | |
| ) | |
| for candidate_id in by_method["summary_candidate_opt"].selected_candidate_ids: | |
| self.assertEqual(by_id[candidate_id].representation_type, "summary") | |
| def test_distribution_field_and_summary_grouping(self) -> None: | |
| rows = evaluate.run_synthetic_benchmark( | |
| seeds=(0, 1), | |
| budgets=(4,), | |
| distributions=("base",), | |
| methods=("opt", "oracle_gvt", "reservoir_raw"), | |
| normal_count=1, | |
| update_count=1, | |
| ) | |
| self.assertTrue(all(row.distribution == "base" for row in rows)) | |
| summary = evaluate.aggregate_results(rows) | |
| self.assertEqual(summary["distributions"], ["base"]) | |
| self.assertIn("by_distribution_budget_method", summary) | |
| self.assertTrue( | |
| all("distribution" in row for row in summary["by_distribution_budget_method"]) | |
| ) | |
| def test_outputs_include_jsonl_json_and_markdown(self) -> None: | |
| rows = evaluate.run_synthetic_benchmark( | |
| seeds=(0, 1), | |
| budgets=(3, 5), | |
| methods=("opt", "oracle_gvt", "no_tombstone_gvt", "no_tombstone_opt"), | |
| normal_count=1, | |
| update_count=1, | |
| ) | |
| with tempfile.TemporaryDirectory() as tmp: | |
| paths = evaluate.write_benchmark_outputs(rows, tmp) | |
| raw_path = Path(paths["raw_jsonl"]) | |
| summary_json_path = Path(paths["summary_json"]) | |
| summary_md_path = Path(paths["summary_md"]) | |
| self.assertTrue(raw_path.exists()) | |
| self.assertTrue(summary_json_path.exists()) | |
| self.assertTrue(summary_md_path.exists()) | |
| raw_rows = [ | |
| json.loads(line) | |
| for line in raw_path.read_text(encoding="utf-8").splitlines() | |
| if line.strip() | |
| ] | |
| self.assertEqual(len(raw_rows), len(rows)) | |
| summary = json.loads(summary_json_path.read_text(encoding="utf-8")) | |
| self.assertIn("by_budget_method", summary) | |
| self.assertIn("Ratio Labels", summary_md_path.read_text(encoding="utf-8")) | |
| def test_coverage_package_export_contains_solver_inputs(self) -> None: | |
| instance = evaluate.generate_synthetic_instance(12, normal_count=2, update_count=1) | |
| expected_positive_rows = sum( | |
| 1 | |
| for candidate in instance.candidates | |
| for value in candidate.coverage.values() | |
| if value > 0 | |
| ) | |
| with tempfile.TemporaryDirectory() as tmp: | |
| paths = evaluate.write_coverage_package(instance, tmp) | |
| for path in paths.values(): | |
| self.assertTrue(Path(path).exists(), path) | |
| manifest = json.loads(Path(paths["manifest"]).read_text(encoding="utf-8")) | |
| self.assertEqual(manifest["instance_id"], instance.instance_id) | |
| self.assertEqual(manifest["counts"]["candidate_memories"], len(instance.candidates)) | |
| self.assertEqual(manifest["counts"]["positive_coverage_rows"], expected_positive_rows) | |
| coverage_rows = [ | |
| json.loads(line) | |
| for line in Path(paths["coverage_matrix"]).read_text(encoding="utf-8").splitlines() | |
| if line.strip() | |
| ] | |
| self.assertEqual(len(coverage_rows), expected_positive_rows) | |
| self.assertTrue(all(0.0 < row["coverage"] <= 1.0 for row in coverage_rows)) | |
| def test_exported_coverage_package_passes_structural_audit(self) -> None: | |
| from scripts.audit_coverage_artifacts import audit_artifact | |
| instance = evaluate.generate_synthetic_instance(13, normal_count=2, update_count=1) | |
| with tempfile.TemporaryDirectory() as tmp: | |
| paths = evaluate.write_coverage_package(instance, tmp) | |
| audit = audit_artifact( | |
| "synthetic_package", | |
| Path(paths["package_dir"]), | |
| "Synthetic OracleMem coverage package.", | |
| sample_rows=1000, | |
| ) | |
| self.assertEqual(audit.format, "coverage_package_dir") | |
| self.assertEqual( | |
| audit.statuses["oracle_denominator"], | |
| "machine-checkable coverage package", | |
| ) | |
| self.assertEqual( | |
| audit.statuses["coverage_matrix"], | |
| "candidate-unit coverage present", | |
| ) | |
| self.assertTrue(all(audit.package_files.values()), audit.package_files) | |
| coverage_rows = [ | |
| json.loads(line) | |
| for line in Path(paths["coverage_matrix"]).read_text(encoding="utf-8").splitlines() | |
| if line.strip() | |
| ] | |
| self.assertTrue(all("candidate_id" in row and "unit_id" in row for row in coverage_rows)) | |
| query_rows = [ | |
| json.loads(line) | |
| for line in Path(paths["queries"]).read_text(encoding="utf-8").splitlines() | |
| if line.strip() | |
| ] | |
| self.assertGreater(len(query_rows), 0) | |
| self.assertTrue(all(row["required_unit_ids"] for row in query_rows)) | |
| if __name__ == "__main__": | |
| unittest.main() | |