Anonymized Continuous Black-Box Optimizer Design

Design a reproducible ask/tell optimizer for 10-dimensional continuous black-box minimization, starting from the inherited uniform-random weak baseline. Minimize the objective under a strict budget of 100 evaluations per instance; for scoring, the submitted optimizer code is re-run on sealed held-out instances drawn from the same anonymized objective family.

Hard Constraints

• Edit only /app/methods/main/solver.py; it must be a self-contained file defining the submitted Optimizer class. The verifier copies only this file into its runner scratch directory, so sibling modules are unavailable.
• Use only the Python standard library and NumPy. The runtime provides NumPy 2.2.6, has no verifier network access, and does not provide other third-party optimization packages.
• Each hidden run has a hard 100-evaluation budget. The verifier owns and enforces the evaluation loop; returning extra points does not grant extra evaluations.
• ask(n) must return a finite NumPy-compatible matrix with between 1 and n rows, exactly dim columns, and every coordinate within the supplied bounds.
• The optimizer must answer within the verifier's per-request and total worker time limits. Import failures, timeouts, crashes, malformed output, non-finite values, and out-of-bounds points invalidate the complete submission.
• The submitted process cannot access the hidden evaluator, hidden instances, frozen normalization data, or objective implementation. It receives only bounds, budget, seed, RNG, requested batch size, evaluated points, and authoritative objective values.

Runtime budget.

Each isolated sealed optimizer run has a 120 seconds total runtime budget for its complete query loop, and each ask or tell response must arrive within 5 seconds. This limit applies to the submitted optimizer, not to your research time. It is shared across 400 independent sealed runs (20 instances × 20 seeds), so each run must average about 0.3 seconds. Use bounded, vectorized per-query work; repeated dense refits or hundreds-wide candidate scans at every observation are unlikely to fit that aggregate budget. The visible self-check is intentionally unlimited and does not relax the sealed runtime budget.

What You Have

• /app/data/visible.json contains six public development instances from the same anonymized objective family. Hidden instances are distinct and sealed.
• /app/methods/main/solver.py is a public uniform-random baseline.
• /app/selfcheck.py is an unlimited visible-data dry run. Execute python /app/selfcheck.py to see the median final visible objective; lower is better.
• The concrete initialization call is Optimizer(dim=dim, lower=lower, upper=upper, budget=budget, seed=seed, rng=np.random.default_rng(seed)), where lower and upper are NumPy arrays and rng is the harness-owned generator.
• The verifier calls ask(n). It then calls either tell(X, y) when metadata is null or tell(X, y, metadata) for an optimizer that accepts the metadata argument. This task currently supplies null metadata, so both two-argument and three-argument tell methods are supported.
• An optional positive integer self.batch requests a preferred batch size, but the verifier always caps requests to the remaining budget.

What You Submit

Submit an optimizer implementation, not a final point or a precomputed answer. Keep the complete implementation in the self-contained /app/methods/main/solver.py; the verifier does not copy sibling modules.

How It Is Judged

For each sealed instance and fixed seed, the verifier repeatedly calls ask, evaluates the returned candidates, and reports lower-is-better values through tell until the query budget is consumed. It builds authoritative best-so-far traces and combines anytime quality with final-query quality under a fixed verifier-only normalization protocol. Higher normalized quality is better; calibration artifacts and the grader mapping remain sealed.