Generate proof-bearing dynamic world histories

tests/test_skeletons.py

@@ -1,75 +1,74 @@
 import unittest
 
-from logicbench.models import Condition, HiddenRule, HiddenSystem
-from logicbench.skeletons import exact_present_probability, generate_skeletons, resolve_length
+from logicbench.skeletons import generate_skeletons, resolve_length
 
 
 class SkeletonTests(unittest.TestCase):
-    def test_short_means_four_query_events(self):
-        skeletons = generate_skeletons(count=3, length="short", seed=42)
-        self.assertEqual([item.complexity for item in skeletons], [4, 4, 4])
-        self.assertTrue(all(len(item.query_case.events) == 4 for item in skeletons))
-        self.assertEqual(
-            [item.gold_answer for item in skeletons], ["PRESENT", "ABSENT", "PRESENT"]
-        )
+    def test_short_world_has_many_entities_and_realized_events(self):
+        skeleton = generate_skeletons(1, "short", seed=42)[0]
+        self.assertEqual(skeleton.entity_count, 128)
+        self.assertEqual(skeleton.simulation_steps, 1000)
+        self.assertGreater(len(skeleton.events), 300)
+        self.assertGreaterEqual(len(skeleton.proof_event_ids), 4)
+        self.assertLess(skeleton.generator_checks["proof_event_ratio"], 0.05)
 
     def test_generation_is_deterministic(self):
-        first = [item.to_dict() for item in generate_skeletons(6, 4, seed=7)]
-        second = [item.to_dict() for item in generate_skeletons(6, 4, seed=7)]
+        first = [item.to_dict() for item in generate_skeletons(4, 4, seed=7)]
+        second = [item.to_dict() for item in generate_skeletons(4, 4, seed=7)]
         self.assertEqual(first, second)
 
-    def test_renderer_receives_behavior_but_no_latent_information(self):
+    def test_renderer_receives_realized_history_but_no_program_or_answer(self):
         skeleton = generate_skeletons(1, "short", seed=1)[0]
         payload = skeleton.renderer_payload()
         for secret in (
             "id",
-            "hidden_system",
+            "hidden_program",
+            "hidden_state",
+            "final_state",
             "gold_answer",
-            "gold_present_probability",
-            "latent_trace",
+            "proof_event_ids",
+            "proof_facts",
+            "generator_checks",
         ):
             self.assertNotIn(secret, payload)
-        self.assertIn("support_cases", payload)
-        self.assertIsNone(payload["query_case"]["observed_present"])
+        self.assertEqual(len(payload["events"]), len(skeleton.events))
+        self.assertEqual(len(payload["entity_types"]), 128)
 
-    def test_exact_enumerator_applies_persistent_veto(self):
-        system = HiddenSystem(
-            initial_record="ABSENT",
-            conflict_policy="PERSISTENT_INVALIDATION_VETO",
-            rules=(
-                HiddenRule("add", "A", (), 0.8, "ADD_RECORD", "record"),
-                HiddenRule("veto", "B", (), 0.25, "INVALIDATE_RECORD", "record"),
-            ),
-        )
-        self.assertAlmostEqual(exact_present_probability(system, {}, ("A", "B")), 0.6)
-        self.assertAlmostEqual(exact_present_probability(system, {}, ("B", "A")), 0.6)
+    def test_query_is_not_directly_stated_and_proof_events_exist(self):
+        for skeleton in generate_skeletons(5, "short", seed=20260922):
+            query_pair = skeleton.query.arguments
+            direct = [
+                event
+                for event in skeleton.events
+                if event.kind == "RELATE"
+                and event.arguments.get("predicate") == skeleton.query.predicate
+                and (event.arguments.get("subject"), event.arguments.get("object")) == query_pair
+            ]
+            self.assertFalse(direct)
+            event_ids = {event.id for event in skeleton.events}
+            self.assertTrue(set(skeleton.proof_event_ids) <= event_ids)
+            self.assertGreaterEqual(len(skeleton.proof_event_ids), skeleton.complexity)
 
-    def test_exact_enumerator_respects_stateful_event_order(self):
-        system = HiddenSystem(
-            initial_record="ABSENT",
-            conflict_policy="PERSISTENT_INVALIDATION_VETO",
-            rules=(
-                HiddenRule("mark", "A", (), 0.5, "SET_FLAG", "ready"),
-                HiddenRule(
-                    "add",
-                    "B",
-                    (Condition("state", "ready", "IS_SET", True),),
-                    0.8,
-                    "ADD_RECORD",
-                    "record",
-                ),
-            ),
-        )
-        self.assertAlmostEqual(exact_present_probability(system, {}, ("A", "B")), 0.4)
-        self.assertEqual(exact_present_probability(system, {}, ("B", "A")), 0.0)
+    def test_world_contains_multiple_logic_domains(self):
+        skeleton = generate_skeletons(1, "short", seed=3)[0]
+        predicates = {
+            event.arguments.get("predicate")
+            for event in skeleton.events
+            if event.kind == "RELATE"
+        }
+        self.assertTrue({"ABOVE", "MEMBER", "SUBSET", "CONNECTED"} <= predicates)
+        kinds = {event.kind for event in skeleton.events}
+        self.assertTrue({"MOVE", "UPDATE_NUMBER", "SET_STATE"} <= kinds)
 
-    def test_length_validation(self):
+    def test_length_and_scale_validation(self):
         self.assertEqual(resolve_length("medium"), 6)
         self.assertEqual(resolve_length("5"), 5)
         with self.assertRaises(ValueError):
             resolve_length("huge")
         with self.assertRaises(ValueError):
-            resolve_length(3)
+            resolve_length(2)
+        with self.assertRaises(ValueError):
+            generate_skeletons(1, "short", entity_count=20)
 
 
 if __name__ == "__main__":