README.md

---
language:
  - en
pretty_name: DFTArtifactBench-50
size_categories:
  - n<1K
tags:
  - benchmark
  - computational-chemistry
  - density-functional-theory
  - scientific-agents
  - code-generation
  - gaussian
  - pyscf
  - gpu4pyscf
---

# DFTArtifactBench-50

DFTArtifactBench-50 is an English computational-chemistry **artifact-generation component benchmark**. Its 50 tasks ask an agent to construct complete, machine-checkable Gaussian, PySCF, or GPU4PySCF workflow directories from bounded local evidence. Every primary answer is a directory of artifacts, rather than a numerical result or prose response.

It evaluates whether supplied scientific contracts are encoded coherently across inputs, manifests, workflow graphs, and preflight evidence. It **does not establish chemical accuracy**, successful SCF convergence, or complete AI Scientist autonomy. No electronic-structure calculation is run by the default evaluator, and candidate Python files are statically parsed rather than imported or executed.

This full release contains reference answers and private evaluator controls under `answers/` and `gold/`. Do not expose those directories to a system being evaluated; use the questions-only exporter for clean evaluation packets.

## Composition

| Family | Tasks |
| --- | ---: |
| Input construction | 10 |
| Silent-failure repair | 10 |
| Multi-stage workflow | 12 |
| Open-shell and metal workflow | 8 |
| Mechanism-to-campaign | 10 |

The engine mix is 20 Gaussian, 20 PySCF, and 10 GPU4PySCF tasks. All task packets are self-contained. The bounded mechanism example `DFA-041` asks for separate SN2 and E2 branches, transition-state checks, both IRC directions, and endpoint artifacts.

## Layout and workflow

After building, public questions are in `tasks/DFA-###/`; each includes `task.json`, `prompt.md`, `output_contract.json`, and any supplied structures, evidence, or starter material. Evaluator control material is kept separately under `gold/` and must be treated as answer contamination when reporting benchmark results.

Each candidate task directory includes a manifest with SHA-256 entries, `workflow.json`, `preflight_report.json`, and the task-specific artifact roles declared by its local output contract. Paths must be normalized relative paths, and symlinks are forbidden.

Build and validate a checkout with only Python's standard library:

```bash
cd dft_artifact_bench_50
python3 build_benchmark.py
python3 validate_benchmark.py
```

The expected validation summary begins with `OK: 50 tasks, 50 reference submissions`.

Evaluate a complete candidate submission root (containing `DFA-001` through `DFA-050`):

```bash
python3 evaluate_submission.py /path/to/submission --output scores.json
```

The report contains mean artifact score, strict successes, engine and family macro tables, hard-gate failures, and per-task diagnostics. A strict pass is score at least 70 plus the three core gates: safe parseable submission, chemical identity consistency, and evidence honesty. Task-specific scientific gates assess charge/spin and electron accounting, ECP/pseudopotential use, dispersion exactly once, exact solvent descriptors, workflow provenance, TS/IRC completeness, open-shell stability evidence, model preservation, and explicit capability limits.

## Questions-only protocol

Create a shareable task package with:

```bash
python3 export_questions_only.py /path/to/questions-only
```

The exporter requires an empty destination, copies only question-facing material and needed schemas, then re-reads and audits the result. Do not evaluate a system against a package that exposed control artifacts; report any prior exposure and the exact release used.

An evaluated solver should begin with `START_HERE.md`. Every task prompt lists eight ordered sections, the exact public files to read, the deliverable tree, safe syntax variations, the three core gates, and its gold-free lint command. Each task also includes `submission_template/` with an answer-free workflow and JSON skeleton derived from the public contract. The release includes shared `templates/`, aligned public schemas, and a standalone check:

```bash
python3 lint_submission.py tasks/DFA-041 /path/to/submission/DFA-041
```

The linter checks the public file, hash, JSON, workflow, Gaussian-section, and static-Python contracts without reading gold. It is a format/public-contract check, not a gold-score preview. Root `CLAIMS.md`, `notes/*.md`, `.DS_Store`, `__pycache__`, and `*.pyc` are unscored; undeclared executable or structured files still fail the contract. Module docstrings, comments, and simple assertions are accepted in Python inputs, while dynamic imports, I/O, `exec`, and `eval` remain forbidden.

The questions-only release intentionally contains no evaluator or reference submission. Run private scoring only from a controlled full benchmark checkout.

## Reproducibility and optional smoke profile

The renderer stages output on the benchmark filesystem and atomically replaces only `tasks/`, `gold/`, and `index.json`. Rebuilding unchanged sources is byte deterministic and preserves unrelated files. The default build, validation, and evaluation paths need neither a Gaussian license nor third-party packages.

An optional, separately configured tiny PySCF smoke profile may be run through the OrbStack-compatible Docker CLI with network disabled and resource limits. It is not part of the default score and must not be represented as proof of chemical accuracy.

## Citation

Edit `CITATION.cff` directly before submission.