Update dataset

README.md

@@ -20,10 +20,10 @@ A benchmark dataset for evaluating AI systems on challenging computer science pr
 
 ## Dataset Description
 
-This dataset contains 260 problems across three categories:
+This dataset contains 262 problems across three categories:
 - **Algorithmic**: 188 competitive programming problems with automated judging
 - **Research**: 66 open-ended research problems
-- **2.0**: 6 next-generation open-ended optimization problems
+- **2.0**: 8 next-generation open-ended optimization problems
 
 ## Dataset Structure
 

data/test-00000-of-00001.json

@@ -252,6 +252,8 @@
 {"problem_id": "vector_addition/2_20", "category": "research", "statement": "Vector Addition Problem - Medium Vectors (2^20)\n================================================\n\nProblem Setting\n---------------\nDesign and optimize high-performance Triton kernels for vector addition on GPU with medium vectors (1,048,576 elements). This problem focuses on implementing efficient element-wise addition for typical workloads.\n\nThe challenge involves optimizing:\n- **Memory access patterns**: Efficient loading and storing of vector data\n- **Block sizing**: Optimal block sizes for GPU execution\n- **Memory bandwidth**: Maximizing throughput for simple arithmetic operations\n- **Performance benchmarking**: Achieving speedup over PyTorch baseline\n\nThis variant tests performance on medium vectors (2^20 = 1,048,576 elements = 4 MB per vector).\n\nTarget\n------\n- **Primary**: Maximize bandwidth (GB/s) over PyTorch baseline (higher is better)\n- **Secondary**: Ensure correctness\n- **Tertiary**: Minimize kernel launch overhead\n\nAPI Specification\n-----------------\nImplement a `Solution` class that returns a Triton kernel implementation:\n\n```python\nclass Solution:\n    def solve(self, spec_path: str = None) -> dict:\n        \"\"\"\n        Returns a dict with either:\n        - {\"code\": \"python_code_string\"}\n        - {\"program_path\": \"path/to/kernel.py\"}\n        \"\"\"\n        # Your implementation\n        pass\n```\n\nYour kernel implementation must provide:\n\n```python\nimport torch\nimport triton\nimport triton.language as tl\n\ndef add(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n    \"\"\"\n    Element-wise addition of two vectors.\n    \n    Args:\n        x: Input tensor of shape (1048576,)\n        y: Input tensor of shape (1048576,)\n    \n    Returns:\n        Output tensor of shape (1048576,) with x + y\n    \"\"\"\n    pass\n```\n\nAPI Usage Notes\n---------------\n- The evaluator looks for an `add` function in the module namespace\n- Function must handle vector size of exactly 1,048,576 elements\n- Must use Triton JIT compilation for kernel definition\n- Should optimize for memory bandwidth\n- Input tensors are guaranteed to be contiguous and same size\n\nScoring (0-100)\n---------------\nPerformance is measured against CPU baseline and PyTorch GPU baseline:\n\n```\ntarget = max(2.0 * (pytorch_bandwidth / cpu_bandwidth), 1.0)\nscore = ((custom_bandwidth / cpu_bandwidth - 1.0) / (target - 1.0)) * 100\n\nWhere:\n- custom_bandwidth = your solution's bandwidth\n- cpu_bandwidth = naive CPU baseline bandwidth\n- pytorch_bandwidth = PyTorch GPU baseline bandwidth\n- target = 2x PyTorch performance vs CPU (normalized to custom vs CPU)\n\nScore is clamped to [0, 100] range\n```\n\n- 0 points = CPU baseline performance (custom/cpu = 1x)\n- 50 points = Halfway between CPU baseline and 2x PyTorch performance\n- 100 points = 2x PyTorch GPU performance vs CPU (custom/cpu = 2 * pytorch/cpu)\n\nEvaluation Details\n------------------\n- Tested on vector size: 2^20 = 1,048,576 elements\n- Performance measured in GB/s (bandwidth)\n- Correctness verified with tolerance: rtol=1e-5, atol=1e-8\n- Performance measured using median execution time across 5 samples\n- Requires CUDA backend and GPU support\n", "config": "dependencies:\n  uv_project: resources\ntag: hpc\nruntime:\n  environment: \"Triton 3.2.0 with CUDA 12.2 (triton-tlx image)\"\n  docker:\n    image: andylizf/triton-tlx:tlx-nv-cu122\n    gpu: true\n"}
 {"problem_id": "vector_addition/2_24", "category": "research", "statement": "Vector Addition Problem - Large Vectors (2^24)\n===============================================\n\nProblem Setting\n---------------\nDesign and optimize high-performance Triton kernels for vector addition on GPU with large vectors (16,777,216 elements). This problem focuses on implementing efficient element-wise addition for high-throughput workloads.\n\nThe challenge involves optimizing:\n- **Memory bandwidth**: Maximizing throughput for large vectors\n- **Memory access patterns**: Efficient loading and storing of vector data\n- **Block sizing**: Optimal block sizes for large vectors\n- **Performance benchmarking**: Achieving speedup over PyTorch baseline\n\nThis variant tests performance on large vectors (2^24 = 16,777,216 elements = 64 MB per vector).\n\nTarget\n------\n- **Primary**: Maximize bandwidth (GB/s) over PyTorch baseline (higher is better)\n- **Secondary**: Minimize kernel launch overhead\n- **Tertiary**: Ensure correctness\n\nAPI Specification\n-----------------\nImplement a `Solution` class that returns a Triton kernel implementation:\n\n```python\nclass Solution:\n    def solve(self, spec_path: str = None) -> dict:\n        \"\"\"\n        Returns a dict with either:\n        - {\"code\": \"python_code_string\"}\n        - {\"program_path\": \"path/to/kernel.py\"}\n        \"\"\"\n        # Your implementation\n        pass\n```\n\nYour kernel implementation must provide:\n\n```python\nimport torch\nimport triton\nimport triton.language as tl\n\ndef add(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n    \"\"\"\n    Element-wise addition of two vectors.\n    \n    Args:\n        x: Input tensor of shape (16777216,)\n        y: Input tensor of shape (16777216,)\n    \n    Returns:\n        Output tensor of shape (16777216,) with x + y\n    \"\"\"\n    pass\n```\n\nAPI Usage Notes\n---------------\n- The evaluator looks for an `add` function in the module namespace\n- Function must handle vector size of exactly 16,777,216 elements\n- Must use Triton JIT compilation for kernel definition\n- Should optimize for small vector performance and launch overhead\n- Input tensors are guaranteed to be contiguous and same size\n\nScoring (0-100)\n---------------\nPerformance is measured against CPU baseline and PyTorch GPU baseline:\n\n```\ntarget = max(2.0 * (pytorch_bandwidth / cpu_bandwidth), 1.0)\nscore = ((custom_bandwidth / cpu_bandwidth - 1.0) / (target - 1.0)) * 100\n\nWhere:\n- custom_bandwidth = your solution's bandwidth\n- cpu_bandwidth = naive CPU baseline bandwidth\n- pytorch_bandwidth = PyTorch GPU baseline bandwidth\n- target = 2x PyTorch performance vs CPU (normalized to custom vs CPU)\n\nScore is clamped to [0, 100] range\n```\n\n- 0 points = CPU baseline performance (custom/cpu = 1x)\n- 50 points = Halfway between CPU baseline and 2x PyTorch performance\n- 100 points = 2x PyTorch GPU performance vs CPU (custom/cpu = 2 * pytorch/cpu)\n\nEvaluation Details\n------------------\n- Tested on vector size: 2^24 = 16,777,216 elements\n- Performance measured in GB/s (bandwidth)\n- Correctness verified with tolerance: rtol=1e-5, atol=1e-8\n- Performance measured using median execution time across 5 samples\n- Requires CUDA backend and GPU support\n", "config": "dependencies:\n  uv_project: resources\ndatasets: []\ntag: hpc\nruntime:\n  docker:\n    image: andylizf/triton-tlx:tlx-nv-cu122\n    gpu: true\n  environment: \"Triton 3.2.0 with CUDA 12.2 (triton-tlx image)\"\n"}
 {"problem_id": "vector_addition/2_28", "category": "research", "statement": "Vector Addition Problem - Very Large Vectors (2^28)\n==============================================\n\nProblem Setting\n---------------\nDesign and optimize high-performance Triton kernels for vector addition on GPU with very large vectors (268,435,456 elements). This problem focuses on implementing efficient element-wise addition for maximum throughput scenarios.\n\nThe challenge involves optimizing:\n- **Memory access patterns**: Efficient loading and storing of large vector data\n- **Block sizing**: Optimal block sizes for large GPU workloads\n- **Memory bandwidth**: Maximizing throughput at scale\n- **Performance benchmarking**: Achieving speedup over PyTorch baseline\n\nThis variant tests performance on very large vectors (2^28 = 268,435,456 elements = 1 GB per vector). Requires ~3 GB GPU memory total.\n\nTarget\n------\n- **Primary**: Maximize bandwidth (GB/s) over PyTorch baseline (higher is better)\n- **Secondary**: Ensure correctness on large vectors\n- **Tertiary**: Minimize memory overhead\n\nAPI Specification\n-----------------\nImplement a `Solution` class that returns a Triton kernel implementation:\n\n```python\nclass Solution:\n    def solve(self, spec_path: str = None) -> dict:\n        \"\"\"\n        Returns a dict with either:\n        - {\"code\": \"python_code_string\"}\n        - {\"program_path\": \"path/to/kernel.py\"}\n        \"\"\"\n        # Your implementation\n        pass\n```\n\nYour kernel implementation must provide:\n\n```python\nimport torch\nimport triton\nimport triton.language as tl\n\ndef add(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n    \"\"\"\n    Element-wise addition of two vectors.\n    \n    Args:\n        x: Input tensor of shape (268435456,)\n        y: Input tensor of shape (268435456,)\n    \n    Returns:\n        Output tensor of shape (268435456,) with x + y\n    \"\"\"\n    pass\n```\n\nAPI Usage Notes\n---------------\n- The evaluator looks for an `add` function in the module namespace\n- Function must handle vector size of exactly 268,435,456 elements\n- Must use Triton JIT compilation for kernel definition\n- Should optimize for maximum memory bandwidth at scale\n- Input tensors are guaranteed to be contiguous and same size\n- May cause OOM on GPUs with less than 3GB memory\n\nScoring (0-100)\n---------------\nPerformance is measured against CPU baseline and PyTorch GPU baseline:\n\n```\ntarget = max(2.0 * (pytorch_bandwidth / cpu_bandwidth), 1.0)\nscore = ((custom_bandwidth / cpu_bandwidth - 1.0) / (target - 1.0)) * 100\n\nWhere:\n- custom_bandwidth = your solution's bandwidth\n- cpu_bandwidth = naive CPU baseline bandwidth\n- pytorch_bandwidth = PyTorch GPU baseline bandwidth\n- target = 2x PyTorch performance vs CPU (normalized to custom vs CPU)\n\nScore is clamped to [0, 100] range\n```\n\n- 0 points = CPU baseline performance (custom/cpu = 1x)\n- 50 points = Halfway between CPU baseline and 2x PyTorch performance\n- 100 points = 2x PyTorch GPU performance vs CPU (custom/cpu = 2 * pytorch/cpu)\n\nEvaluation Details\n------------------\n- Tested on vector size: 2^28 = 268,435,456 elements\n- Performance measured in GB/s (bandwidth)\n- Correctness verified with tolerance: rtol=1e-5, atol=1e-8\n- Performance measured using median execution time across 5 samples\n- Requires CUDA backend and GPU support\n- Requires sufficient GPU memory (may OOM on smaller GPUs)\n", "config": "dependencies:\n  uv_project: resources\ndatasets: []\ntag: hpc\nruntime:\n  docker:\n    image: andylizf/triton-tlx:tlx-nv-cu122\n    gpu: true\n  environment: \"Triton 3.2.0 with CUDA 12.2 (triton-tlx image)\"\n"}
+{"problem_id": "bboplace_direct_iccad2015", "category": "2.0", "statement": "BBOPlace Direct ICCAD2015\n========================\n\nDirectly submit one JSON macro placement for a single BBOPlace ICCAD2015\ndesign: `superblue1`. The hidden judge evaluates the placement with the\noriginal BBOPlace-Bench MGO MP-HPWL evaluator.\n\nRuntime and resources\n---------------------\n\nYour final submission is a JSON file at `/app/solution.json`. You are encouraged\nto write Python programs, shell scripts, search loops, local parsers, or any\nother helper code in `/app` while working. Those programs may generate and\noverwrite `/app/solution.json` many times. Only the final JSON artifact is\ngraded.\n\nThe agent container provides:\n\n- 8 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available for local helper scripts\n- hidden benchmark data is not available in the agent workspace\n\nThe judge also runs on CPU only. Do not rely on CUDA, DREAMPlace, Ray, or GPU\nplacement libraries for scoring.\n\nSubmission format\n-----------------\n\nSubmit exactly one placement for `superblue1` by writing `/app/solution.json`.\nAfter your program writes the file, call `bash /app/submit.sh` to score that\nJSON. The JSON must use one of these forms:\n\n```json\n{\"placement\": [0.0, 0.0, \"...\"]}\n```\n\nor:\n\n```json\n{\"x\": [0.0, 0.0, \"...\"], \"y\": [0.0, 0.0, \"...\"]}\n```\n\nThe placement vector length must equal `dim = 2 * node_cnt`. The first\n`node_cnt` entries are x-grid coordinates and the remaining `node_cnt` entries\nare y-grid coordinates. Coordinates must be finite, with x in `[0, n_grid_x]`\nand y in `[0, n_grid_y]`. Only one placement is accepted.\n\nThe judge discloses public metadata through the iterative feedback path,\nincluding `dim`, `node_cnt`, `n_grid_x`, `n_grid_y`, and the baseline HPWL.\nThe netlist and evaluator source stay hidden in the judge image.\n\nScore\n-----\n\nThe objective is to minimize MP-HPWL for `superblue1`:\n\n`raw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl`\n\n`score = max(0, raw_score)`\n\nThe baseline constant is from the BBOPlace-Bench report, Table V, `MGO + PSO`\nMP-HPWL. The paper reports values in units of `x10^5`; the judge stores the\nraw HPWL value relaxed by `1.2x`:\n\n- `superblue1`: `0.696e5`\n\nBoth iterative submissions and final verification evaluate this same single\ndesign. The submit helper may still save the best iterative JSON artifact and\nrerun it during final verification.\n", "config": "tag: optimization\nruntime:\n  language: json\n  timeout_seconds: 10800\n  environment: \"JSON placement for one hidden ICCAD2015 BBOPlace design\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nsubmission:\n  kind: file\n  path: /app/solution.json\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
+{"problem_id": "bboplace_direct_ispd2005", "category": "2.0", "statement": "BBOPlace Direct ISPD2005\n=======================\n\nDirectly submit one JSON macro placement for a single BBOPlace ISPD2005 design:\n`adaptec1`. The hidden judge evaluates the placement with the original\nBBOPlace-Bench MGO MP-HPWL evaluator.\n\nRuntime and resources\n---------------------\n\nYour final submission is a JSON file at `/app/solution.json`. You are encouraged\nto write Python programs, shell scripts, search loops, local parsers, or any\nother helper code in `/app` while working. Those programs may generate and\noverwrite `/app/solution.json` many times. Only the final JSON artifact is\ngraded.\n\nThe agent container provides:\n\n- 8 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available for local helper scripts\n- hidden benchmark data is not available in the agent workspace\n\nThe judge also runs on CPU only. Do not rely on CUDA, DREAMPlace, Ray, or GPU\nplacement libraries for scoring.\n\nSubmission format\n-----------------\n\nSubmit exactly one placement for `adaptec1` by writing `/app/solution.json`.\nAfter your program writes the file, call `bash /app/submit.sh` to score that\nJSON. The JSON must use one of these forms:\n\n```json\n{\"placement\": [0.0, 0.0, \"...\"]}\n```\n\nor:\n\n```json\n{\"x\": [0.0, 0.0, \"...\"], \"y\": [0.0, 0.0, \"...\"]}\n```\n\nThe placement vector length must equal `dim = 2 * node_cnt`. The first\n`node_cnt` entries are x-grid coordinates and the remaining `node_cnt` entries\nare y-grid coordinates. Coordinates must be finite, with x in `[0, n_grid_x]`\nand y in `[0, n_grid_y]`. Only one placement is accepted.\n\nThe judge discloses public metadata through the iterative feedback path,\nincluding `dim`, `node_cnt`, `n_grid_x`, `n_grid_y`, and the baseline HPWL.\nThe netlist and evaluator source stay hidden in the judge image.\n\nScore\n-----\n\nThe objective is to minimize MP-HPWL for `adaptec1`:\n\n`raw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl`\n\n`score = max(0, raw_score)`\n\nThe baseline constant is from the BBOPlace-Bench report, Table III,\n`MGO + Vanilla-EA` MP-HPWL. The paper reports values in units of `x10^5`; the\njudge stores the raw HPWL value relaxed by `1.2x`:\n\n- `adaptec1`: `6.96e5`\n\nBoth iterative submissions and final verification evaluate this same single\ndesign. The submit helper may still save the best iterative JSON artifact and\nrerun it during final verification.\n", "config": "tag: optimization\nruntime:\n  language: json\n  timeout_seconds: 10800\n  environment: \"JSON placement for one hidden ISPD2005 BBOPlace design\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nsubmission:\n  kind: file\n  path: /app/solution.json\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
 {"problem_id": "bboplace_iccad2015", "category": "2.0", "statement": "BBOPlace ICCAD2015\n==================\n\nWrite a Python solution that proposes macro placements for the BBOPlace MGO\nformulation on the ICCAD2015 benchmark suite. The hidden judge evaluates your\nplacements with the original BBOPlace-Bench MP-HPWL evaluator.\n\nRuntime and resources\n---------------------\n\nYour solution runs in the main agent container with:\n\n- 8 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available\n- internet access may be available during the trial, but the benchmark data is\n  hidden and is not available in the agent workspace\n\nThe final verifier timeout is 10800 seconds. The judge also runs on CPU only.\nDo not rely on CUDA, DREAMPlace, Ray, or GPU placement libraries for scoring;\nthe official metric path used here is MGO with MP-HPWL.\n\nYour file must define one of:\n\n- `solve(info)`\n- `generate(info)`\n- `run(info)`\n- `CANDIDATES`, `CANDIDATE`, or `PLACEMENT`\n\nThe recommended interface is `solve(info)`. The judge calls it once per\nbenchmark. `info` contains:\n\n- `benchmark`: one of `superblue1`, `superblue3`, `superblue4`, `superblue5`,\n  `superblue7`, `superblue10`, `superblue16`, `superblue18`\n- `dim`: placement vector length\n- `node_cnt`: number of macros\n- `n_grid_x`, `n_grid_y`: MGO grid bounds\n- `max_candidates_per_submission`: 16\n- `baseline_hpwl`: the baseline HPWL used for scoring\n\nReturn either one placement vector of length `dim`, or a 2D list/array with up\nto 16 placement candidates. For MGO, the first `node_cnt` entries are x-grid\ncoordinates in `[0, n_grid_x]`, and the remaining `node_cnt` entries are y-grid\ncoordinates in `[0, n_grid_y]`.\n\nScore\n-----\n\nThe objective is to minimize MP-HPWL. For each benchmark:\n\n`raw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl`\n\n`score = max(0, raw_score)`\n\nThe final score is the mean score over the eight ICCAD2015 benchmarks. The\nunbounded score is the mean raw score before the zero clip.\n\nDuring iterative agent submissions, `/app/submit.sh` gives quick feedback on\n`superblue1` only. The final verifier evaluates the full eight-benchmark suite.\nUse the quick feedback to debug general placement logic, not as the complete\nleaderboard score.\n\nThe submit helper saves the best quick-feedback artifact it has seen. During\nfinal verification, the verifier reruns both the current `/app/solution.py` and\nthat saved best iterative artifact on the full suite, then uses the better\nfull-suite score. A quick-feedback score is never used directly as the final\nreward.\n\nThe baseline constants are from the BBOPlace-Bench report, Table V,\n`MGO + PSO` MP-HPWL. The paper reports values in units of `x10^5`; the judge\nstores raw HPWL values relaxed by `1.2x`:\n\n- `superblue1`: `0.696e5`\n- `superblue3`: `1.824e5`\n- `superblue4`: `1.128e5`\n- `superblue5`: `4.512e5`\n- `superblue7`: `2.028e5`\n- `superblue10`: `0.648e5`\n- `superblue16`: `1.152e5`\n- `superblue18`: `0.576e5`\n\nThe benchmark data and evaluator source are only present in the judge image.\nThey are not available in the agent workspace.\n", "config": "tag: optimization\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python solution returning BBOPlace MGO placement candidates; hidden ICCAD2015 judge data\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
 {"problem_id": "bboplace_ispd2005", "category": "2.0", "statement": "BBOPlace ISPD2005\n=================\n\nWrite a Python solution that proposes macro placements for the BBOPlace MGO\nformulation on the ISPD2005 benchmark suite. The hidden judge evaluates your\nplacements with the original BBOPlace-Bench MP-HPWL evaluator.\n\nRuntime and resources\n---------------------\n\nYour solution runs in the main agent container with:\n\n- 8 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available\n- internet access may be available during the trial, but the benchmark data is\n  hidden and is not available in the agent workspace\n\nThe final verifier timeout is 10800 seconds. The judge also runs on CPU only.\nDo not rely on CUDA, DREAMPlace, Ray, or GPU placement libraries for scoring;\nthe official metric path used here is MGO with MP-HPWL.\n\nYour file must define one of:\n\n- `solve(info)`\n- `generate(info)`\n- `run(info)`\n- `CANDIDATES`, `CANDIDATE`, or `PLACEMENT`\n\nThe recommended interface is `solve(info)`. The judge calls it once per\nbenchmark. `info` contains:\n\n- `benchmark`: one of `adaptec1`, `adaptec2`, `adaptec3`, `adaptec4`,\n  `bigblue1`, `bigblue3`\n- `dim`: placement vector length\n- `node_cnt`: number of macros\n- `n_grid_x`, `n_grid_y`: MGO grid bounds\n- `max_candidates_per_submission`: 16\n- `baseline_hpwl`: the baseline HPWL used for scoring\n\nReturn either one placement vector of length `dim`, or a 2D list/array with up\nto 16 placement candidates. For MGO, the first `node_cnt` entries are x-grid\ncoordinates in `[0, n_grid_x]`, and the remaining `node_cnt` entries are y-grid\ncoordinates in `[0, n_grid_y]`.\n\nScore\n-----\n\nThe objective is to minimize MP-HPWL. For each benchmark:\n\n`raw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl`\n\n`score = max(0, raw_score)`\n\nThe final score is the mean score over the six ISPD2005 benchmarks. The\nunbounded score is the mean raw score before the zero clip.\n\nDuring iterative agent submissions, `/app/submit.sh` gives quick feedback on\n`adaptec1` only. The final verifier evaluates the full six-benchmark suite.\nUse the quick feedback to debug general placement logic, not as the complete\nleaderboard score.\n\nThe submit helper saves the best quick-feedback artifact it has seen. During\nfinal verification, the verifier reruns both the current `/app/solution.py` and\nthat saved best iterative artifact on the full suite, then uses the better\nfull-suite score. A quick-feedback score is never used directly as the final\nreward.\n\nThe baseline constants are from the BBOPlace-Bench report, Table III,\n`MGO + Vanilla-EA` MP-HPWL. The paper reports values in units of `x10^5`; the\njudge stores raw HPWL values relaxed by `1.2x`:\n\n- `adaptec1`: `6.96e5`\n- `adaptec2`: `73.752e5`\n- `adaptec3`: `67.356e5`\n- `adaptec4`: `68.148e5`\n- `bigblue1`: `2.76e5`\n- `bigblue3`: `62.88e5`\n\nThe benchmark data and evaluator source are only present in the judge image.\nThey are not available in the agent workspace.\n", "config": "tag: optimization\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python solution returning BBOPlace MGO placement candidates; hidden ISPD2005 judge data\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
 {"problem_id": "erdos_demo", "category": "2.0", "statement": "# Erdos Unit Distance Demo\n\n## Problem\n\nPlace exactly `N = 10` distinct points in the Euclidean plane so that the\nnumber of point pairs at Euclidean distance exactly `1` is as large as possible.\n\nThis is a tiny, visually inspectable demo version of the planar unit distance\nproblem. If your construction naturally has a different common distance, scale\nthe coordinates before returning them.\n\n## Program Interface\n\nSubmit a Python file defining one of the following:\n\n```python\ndef solve(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\ndef generate_points(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\nPOINTS = [(0.0, 0.0), (1.0, 0.0), ...]\n```\n\nThe returned value must contain exactly 10 two-dimensional points. No stdin is\nused.\n\n## Validity Constraints\n\nA solution is valid if:\n\n1. It returns exactly 10 points.\n2. Every coordinate is a finite real number.\n3. No two points are closer than `1e-6`.\n\nThe objective is translation-invariant. Very large coordinates are allowed as\nlong as pairwise squared distances remain finite.\n\n## Objective\n\nFor all unordered point pairs, count those whose squared Euclidean distance is\nequal to `1` within a small floating-point tolerance. Let `M` be that count.\n\nMaximize `M`.\n\n## Scoring\n\nThe score is naturally scaled to `[0, 100)`, without clipping against a fixed\ntarget. Let:\n\n```text\nbaseline = N\nX = M\n```\n\nIf the point set is invalid, or if `X <= baseline`, the score is `0`. Otherwise:\n\n```text\nscore = 100 * (X - baseline) / X\n```\n\nThis makes the simple `N`-pair baseline worth `0`. With only 10 points, the\nproblem is intended as a quick sanity check and visual demo for agent workflows.\n", "config": "tag: geometry\nruntime:\n  language: python\n  timeout_seconds: 300\n  environment: \"Python 3.11; no external packages required\"\n  docker:\n    image: ubuntu:24.04\n"}