hillclimb

# 13 points in the plane; score = min triangle area / convex hull area
N, N_TRIANGLES = 13, 286

def fail(reason):
    write_report(0.0, report_error=reason)   # invalid configurations score 0
    sys.exit(0)

df = pd.read_csv("submission.csv")   # id,x,y
if len(df) != N or sorted(df["id"].tolist()) != list(range(N)):
    fail(f"need exactly {N} rows with id 0..{N - 1}")
points = df.sort_values("id")[["x", "y"]].to_numpy(float)
if not np.all(np.isfinite(points)):
    fail("coordinates must be finite")

# translation and uniform scaling leave the score unchanged; normalize
# so very large or very small valid coordinates stay numerically safe
points = points - points[0]
points = points / np.max(np.abs(points))

hull_area = polygon_area(convex_hull(points))
if hull_area <= np.finfo(float).eps:
    fail("degenerate convex hull")

# the smallest of all C(13,3) = 286 triangles, relative to the hull
min_area = min(
    0.5 * abs(cross(points[i], points[j], points[k]))
    for i, j, k in combinations(range(N), 3)
)
write_report(min_area / hull_area)   # -> $HILLCLIMB_RESULT

"""Multi-start global search over diverse hull/interior topologies for
the normalized Heilbronn problem (13 points), each candidate polished
with an epigraph SLSQP formulation (maximize t = min triangle area
subject to a fixed convex-hull area of 1), keeping the best
true-scored configuration found.
"""

def true_score(pts):
    area, hull_idx = hull_area_and_indices(pts)   # scipy ConvexHull
    tri = triangle_areas(pts)                     # all 286 of them
    return float(tri.min() / area)

def polish(pts0, maxiter=150):
    # pin every triangle's orientation, then push up the smallest
    # signed area as an epigraph variable t
    pts_g, hull_idx = gauge_normalize(pts0)       # hull area -> 1
    signs = np.sign(triangle_crosses(pts_g))

    def tri_cons(x):
        pts, t = unpack(x)
        return signs * triangle_crosses(pts) * 0.5 - t   # area_i >= t

    res = minimize(neg_t, x_init, jac=neg_t_grad, method="SLSQP",
                   constraints=[{"type": "eq", "fun": hull_eq},
                                {"type": "ineq", "fun": tri_cons}],
                   options={"maxiter": maxiter, "ftol": 1e-14})
    return unpack(res.x)[0]

def main():
    best_pts = polish_iterated(REF_PTS, rounds=3)  # known-good seed
    best_score = true_score(best_pts)

    # phase 1: broad exploration across hull/interior topologies
    for kind, hull_size in starters:               # hull sizes 8..13
        if time.time() > phase1_deadline:
            break
        pts = polish_iterated(make_start(kind, hull_size), rounds=2)
        if pts is not None and true_score(pts) > best_score:
            best_pts, best_score = pts, true_score(pts)

    # phase 2: basin-hopping local search around the current best
    while time.time() - start < TIME_BUDGET_S:
        pts = polish_iterated(perturb(best_pts), rounds=2)
        if pts is not None and true_score(pts) > best_score:
            best_pts, best_score = pts, true_score(pts)

    # final tight refinement of the winner, then write it out
    best_pts = polish_iterated(best_pts, rounds=4, maxiter=400)
    write_csv("submission.csv", best_pts)

class SearchPolicy(Protocol):
    name: str
    params: dict

    # one Action -- draft | debug | improve | ensemble --
    # or None to hold the slot open
    def propose(self, view: SearchView) -> Action | None: ...

    # every terminal result, and replayed on resume
    def observe(self, view: SearchView, candidate: Candidate) -> None: ...

class OperatorBackend(Protocol):
    name: str

    # take a prompt and a working directory, write code, report what happened
    def invoke(self, request: OperatorRequest) -> OperatorResult: ...

class DataStore(Protocol):
    # upserts for runs, searches and status; appends for the journal;
    # a consume-once queue for commands
    def record_run(self, meta: RunMeta) -> None: ...
    def record_search(self, meta: SearchMeta) -> None: ...
    def runs(self) -> list[RunMeta]: ...
    def searches(self, problem_key=None, run_id=None) -> list[SearchRecord]: ...
    def search(self, key: SearchKey) -> SearchRecord | None: ...
    def journal(self, key: SearchKey) -> JournalBackend: ...
    def write_status(self, key: SearchKey, status: SearchStatus) -> None: ...
    def read_status(self, key: SearchKey) -> SearchStatus | None: ...
    def enqueue_command(self, key: SearchKey, cmd: ControlCommand) -> None: ...
    def drain_commands(self, key: SearchKey) -> list[ControlCommand]: ...
    def clear_stale_stops(self, key: SearchKey) -> None: ...
    def close(self) -> None: ...