File size: 9,121 Bytes
6aeb377 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 | import json
import tempfile
import unittest
from pathlib import Path
from swarm_ctf_eval.arena import (
Action,
AgentState,
ArenaEnv,
GameState,
Node,
WAIT,
legal_actions,
observe_node,
redundant_agents,
state_to_dict,
step,
)
from swarm_ctf_eval.arena_generation import generate_state
from swarm_ctf_eval.arena_eval import OracleArenaModel, evaluate_case
from swarm_ctf_eval.arena_oracle import deterministic_policy, solve_joint_action
from swarm_ctf_eval.arena_protocol import (
action_prompt,
encode_action,
parse_action,
parse_broadcast,
)
from swarm_ctf_eval.arena_sft import generate_dataset, oracle_broadcast, write_dataset
def two_node_state() -> GameState:
nodes = {
"X": Node("X", ("Y",), "BLUE"),
"Y": Node("Y", ("X",), "RED"),
}
agents = {}
for team, position in (("BLUE", "X"), ("RED", "Y")):
for index in range(4):
aid = f"{team.lower()}-{index}"
agents[aid] = AgentState(aid, team, position, 2)
knowledge = {
aid: {node_id: observe_node(node, 0) for node_id, node in nodes.items()}
for aid in agents
}
state = GameState(0, nodes, agents, knowledge)
state.validate()
return state
class ArenaTests(unittest.TestCase):
def test_generation_is_deterministic_and_valid(self) -> None:
first = generate_state(17)
second = generate_state(17)
other = generate_state(18)
self.assertEqual(state_to_dict(first), state_to_dict(second))
self.assertNotEqual(state_to_dict(first), state_to_dict(other))
first.validate()
def test_probe_capture_is_complementary_not_duplicate(self) -> None:
state = two_node_state()
actions = {aid: WAIT for aid in state.agents}
actions["blue-0"] = Action("PROBE", "Y")
actions["blue-1"] = Action("CAPTURE", "Y")
result = step(state, actions)
self.assertEqual(result.state.nodes["Y"].owner, "BLUE")
self.assertEqual(result.duplicate_targets["BLUE"], ())
self.assertEqual(redundant_agents(state, actions, "BLUE"), ())
def test_simultaneous_fortify_blocks_one_probe(self) -> None:
state = two_node_state()
actions = {aid: WAIT for aid in state.agents}
actions["blue-0"] = Action("PROBE", "Y")
actions["blue-1"] = Action("CAPTURE", "Y")
actions["red-0"] = Action("FORTIFY", "Y")
result = step(state, actions)
self.assertEqual(result.state.nodes["Y"].owner, "RED")
self.assertFalse(result.state.nodes["Y"].exposed)
def test_resolution_does_not_depend_on_action_dict_order(self) -> None:
state = generate_state(3)
actions = {
**deterministic_policy(state, "BLUE"),
**deterministic_policy(state, "RED"),
}
forward = step(state, actions)
reverse = step(state, dict(reversed(list(actions.items()))))
self.assertEqual(state_to_dict(forward.state), state_to_dict(reverse.state))
self.assertEqual(forward.rewards, reverse.rewards)
self.assertEqual(forward.duplicate_targets, reverse.duplicate_targets)
self.assertAlmostEqual(forward.rewards["BLUE"] + forward.rewards["RED"], 0.0)
def test_invalid_action_is_rejected_and_penalized(self) -> None:
state = two_node_state()
baseline = step(state, {aid: WAIT for aid in state.agents})
invalid = {aid: WAIT for aid in state.agents}
invalid["blue-0"] = Action("CAPTURE", "NOT_A_NODE")
result = step(state, invalid)
self.assertEqual(result.invalid_agents, ("blue-0",))
self.assertEqual(result.rewards["BLUE"], baseline.rewards["BLUE"] - 1.0)
def test_exact_solver_returns_only_optimal_actions(self) -> None:
state = generate_state(5)
red = deterministic_policy(state, "RED")
solution = solve_joint_action(state, "BLUE", red)
self.assertGreater(solution.explored, 0)
self.assertGreaterEqual(solution.optimal_count, len(solution.assignments))
for assignment in solution.assignments:
result = step(state, {**red, **dict(assignment)})
self.assertAlmostEqual(result.rewards["BLUE"], solution.reward)
def test_strict_protocol_rejects_extra_text_and_unsupported_facts(self) -> None:
state = generate_state(9)
aid = "blue-0"
self.assertFalse(parse_broadcast('answer: {"facts":[],"intent":null,"request_resource":0}', state, aid).valid)
hallucination = json.dumps(
{
"facts": [{"node": "ZZ", "owner": "RED", "status": "EXPOSED", "value": 3, "critical": False, "observed_turn": 0}],
"intent": None,
"request_resource": 0,
}
)
self.assertEqual(parse_broadcast(hallucination, state, aid).errors, ("unsupported_fact",))
known = next(iter(state.knowledge[aid].values()))
stale_lie = json.dumps(
{
"facts": [{"node": known.node, "owner": known.owner, "status": known.status, "value": known.value, "critical": known.critical, "observed_turn": known.observed_turn + 1}],
"intent": None,
"request_resource": 0,
}
)
self.assertEqual(parse_broadcast(stale_lie, state, aid).errors, ("unsupported_fact",))
def test_action_protocol_accepts_exactly_displayed_action(self) -> None:
state = generate_state(4)
prompt, displayed = action_prompt(state, "blue-0", [], permutation=2)
self.assertEqual(prompt[0]["role"], "system")
target = encode_action(displayed[-1], displayed)
parsed = parse_action(target, displayed)
self.assertTrue(parsed.valid)
self.assertEqual(parsed.value, displayed[-1])
self.assertFalse(parse_action(target + "\nthanks", displayed).valid)
def test_sft_dataset_is_valid_deduplicated_and_seed_isolated(self) -> None:
rows, manifest = generate_dataset(0, 3)
self.assertEqual(manifest["num_examples"], len(rows))
self.assertEqual(len({row["id"] for row in rows}), len(rows))
for row in rows:
self.assertEqual([message["role"] for message in row["messages"]], ["system", "user", "assistant"])
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)
write_dataset(rows, manifest, output)
self.assertTrue((output / "manifest.json").is_file())
written = sum(len((output / f"{split}.jsonl").read_text().splitlines()) for split in ("train", "validation", "test"))
self.assertEqual(written, len(rows))
def test_targeted_sft_covers_wait_scan_and_transfer(self) -> None:
rows, _ = generate_dataset(0, 1, mechanics_per_kind=1, silence_examples=1)
skills = {
row["metadata"].get("targeted_skill")
for row in rows
if row["metadata"].get("generator_mode") == "targeted_mechanics"
}
self.assertEqual(skills, {"WAIT", "SCAN", "TRANSFER", "SILENCE"})
silence = next(row for row in rows if row["metadata"].get("targeted_skill") == "SILENCE")
self.assertEqual(
json.loads(silence["messages"][-1]["content"]),
{"facts": [], "intent": None, "request_resource": 0},
)
def test_every_generated_agent_has_wait_and_legal_policy_action(self) -> None:
state = generate_state(21)
for team in ("BLUE", "RED"):
policy = deterministic_policy(state, team)
for aid, action in policy.items():
self.assertIn(WAIT, legal_actions(state, aid))
self.assertIn(action, legal_actions(state, aid))
def test_parallel_environment_runs_to_fixed_horizon(self) -> None:
env = ArenaEnv(seed=44, horizon=2)
observations = env.reset()
self.assertEqual(len(observations), 8)
for turn in range(2):
actions = {agent_id: WAIT for agent_id in observations}
observations, rewards, terminated, truncated, info = env.advance(actions)
self.assertAlmostEqual(rewards["BLUE"] + rewards["RED"], 0.0)
self.assertEqual(len(observations), 8)
self.assertIn("team_value", info)
if turn == 0:
self.assertFalse(truncated)
self.assertTrue(terminated or truncated)
def test_oracle_has_no_protocol_false_negatives_and_reaches_optimum(self) -> None:
state = generate_state(101)
reference = deterministic_policy(state, "BLUE")
shuffled = {
aid: oracle_broadcast(state, aid, reference[aid])
for aid in reference
}
row = evaluate_case(OracleArenaModel(), 101, 12, "balanced", shuffled)
self.assertEqual(row["message_strict_rate"], 1.0)
self.assertTrue(row["action_order_consistent"])
for condition in row["conditions"]:
self.assertEqual(condition["strict_action_rate"], 1.0)
self.assertTrue(condition["optimal_outcome"])
if __name__ == "__main__":
unittest.main()
|