Head-to-Head Racing Strategy

You inherit a weak but legal racing agent and must improve its solve() so that its ego car beats a pool of opponent policies in wheel-to-wheel races. Your solve() returns a compact ego-policy parameter set (racing line, speed, overtake and defend behaviour); it is re-run on unseen tracks against the same opponent pool you can see, racing both start orders, and scored by the net result — lower cost (more clean wins) is better.

Hard Constraints

• Implement solve(problem: dict) -> dict. It is called once and must return within 600 seconds of wall time; if it has not returned by then the run is scored 0. problem gives visible_cases (race and score them locally against the public opponent pool with the public simulator), the opponent_pool names, and the parameter bounds.
• Returned fields are clamped to their legal bounds; anything missing falls back to the default, so a partial policy is always legal. The tunable ego parameters are:
• line [0,1] — how far onto the racing line (0 = track centre, 1 = full racing line).
• v_push [0.85,1.02] — target speed as a fraction of the grip-limited profile.
• ot_gap [2,26] m — gap to a car ahead at which you commit to an overtake.
• ot_side [-1,1] — preferred passing side.
• ot_aggr [0,1] — extra speed carried into an overtake (more pace, more contact risk).
• def_bias [0,1] — how hard you move to block a car behind when leading.
• def_gap [4,22] m, follow [3,12] m — defend range and safe-following distance.
• You may only change the returned policy — not the simulator, the tracks, or the opponents.
• Deliberately causing a collision loses: collisions you are responsible for and off-track excursions are penalised, so a reckless dive that trades a pass for contact can score worse than a clean second place.

What You Have

• methods/main/solver.py — the weak baseline you edit in place (returns {}, the cautious pure-pursuit default that gets held up and picked off).
• sim/ — the exact deterministic simulator used for scoring: track.py (track geometry), racesim.py (quasi-steady speed + the two-car time-stepped race with overtaking, blocking, collision responsibility and off-track detection), policies.py (the ego policy machinery and the public opponent pool), problem.py (evaluate, visible_cases, the cost definition). Read them to understand the rules.
• selfcheck.py — races your current solve() over the visible cases and prints the mean cost and win rate. Iterate against it.

What You Submit

Your edited methods/main/solver.py (plus any helper modules under methods/). The verifier re-runs solve() and races the returned policy against the sealed opponents; only the solve(problem) -> policy contract above is relied upon.

How It Is Judged

The sealed verifier calls your solve(), then races the returned ego policy against each opponent on each hidden track, both start orders. Each race scores -clip(win_margin, -5, +5) + collision + off-track penalties; the mean cost over the hidden cases is your score, lower is better, and your reward rises as it drops. The held-out uses the same opponent pool you can see (including the aggressive counter style) on three unseen tracks drawn from the same generator as the visible ones — so a policy that genuinely races well transfers. The residual difficulty is that the best line and passing side for the visible tracks are not quite optimal for the unseen ones: favour a robust set-up over one hand-fit to the three public layouts.