Initial upload of NL→MLIR benchmark

LICENSE

@@ -0,0 +1,19 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+See the full Apache-2.0 text at https://www.apache.org/licenses/LICENSE-2.0.txt
+
+Copyright (c) 2026 Anonymous (double-blind submission, NeurIPS 2026 E&D Track).

README.md

@@ -0,0 +1,95 @@
+---
+license: apache-2.0
+language:
+- en
+pretty_name: Linalg-Spec-30
+size_categories:
+- n<1K
+task_categories:
+- text-generation
+- text2text-generation
+tags:
+- mlir
+- code-generation
+- compiler
+- constrained-decoding
+- linalg
+- memref
+configs:
+- config_name: default
+  data_files:
+  - split: test
+    path: data/test.jsonl
+---
+
+# Linalg-Spec-30
+
+Hand-authored NL→MLIR pairs for linalg named ops under memref semantics (n=30).
+
+This dataset is one of six NL→MLIR benchmarks released alongside the NeurIPS
+2026 Evaluations & Datasets track paper *Cross-Dialect Generalization Without
+Retraining: Benchmarks and Evaluation of Schema-Derived Constrained Decoding
+for MLIR* (anonymous submission). The full suite — `MLIR-Spec-150`,
+`Linalg-Spec-30`, `StableHLO-Spec-30`, `StableHLO-Held-Out-200`,
+`StableHLO-OutOfGrammar-25`, and `MLIR-Functional-Reference-30` — totals 465
+instances across three MLIR dialects.
+
+## Composition
+
+- **Instances**: 30
+- **Format**: one JSON record per line in `data/test.jsonl`
+- **Schema**: fields = `dialect`, `difficulty`, `id`, `mlir`, `nl`, `notes`
+- **Verifier**: `mlir-opt --verify-diagnostics` against pinned LLVM 19.1.7
+- **License**: Apache-2.0 (SPDX: Apache-2.0). No third-party IP restrictions.
+
+## Loading
+
+```python
+from datasets import load_dataset
+ds = load_dataset("plawanrath/Linalg-Spec-30", split="test")
+print(ds[0])
+```
+
+Each record is a self-contained natural-language→MLIR pair; verify-valid
+pass-rate under the dialect's verifier is the primary evaluation metric.
+
+## Source format
+
+For paper reproducibility, individual per-record JSON files (the
+`examples/*.json` layout used by the companion code repository) and the
+MLCommons Croissant 1.0 metadata (`croissant.json`) ship together with the
+release. The JSONL file at `data/test.jsonl` is the canonical HuggingFace
+interface; it is generated 1-to-1 from the source records.
+
+## Datasheet
+
+A full Gebru-style datasheet covering motivation, collection, preprocessing,
+uses, distribution, and maintenance is included in the companion
+reproducibility archive (`docs/datasheets/datasheet.md`). Key points:
+
+- All reference MLIR programs are verifier-clean at the time of release.
+- Hand-authored single-author (no crowdsourcing, no LLM-authored references).
+- Test-only — fine-tuning on these benchmarks contaminates future evaluation
+  and is explicitly out of scope.
+
+## Companion artifacts
+
+- Reproducibility archive (code + scripts): `submission_artifact.tar.gz`
+  in the OpenReview attachment / Zenodo mirror.
+- Companion code repository: <will be populated at camera-ready>.
+
+## Citation
+
+```
+@inproceedings{anonymous2026crossdialect,
+  title     = {Cross-Dialect Generalization Without Retraining: Benchmarks and Evaluation of Schema-Derived Constrained Decoding for MLIR},
+  author    = {Anonymous},
+  booktitle = {Advances in Neural Information Processing Systems (NeurIPS), Datasets and Benchmarks Track},
+  year      = {2026},
+  note      = {Anonymous submission under review.}
+}
+```
+
+## License
+
+Apache-2.0. See `LICENSE`.

croissant.json

@@ -0,0 +1,110 @@
+{
+  "@context": {
+    "@language": "en",
+    "@vocab": "https://schema.org/",
+    "sc": "https://schema.org/",
+    "cr": "http://mlcommons.org/croissant/",
+    "rai": "http://mlcommons.org/croissant/RAI/",
+    "dct": "http://purl.org/dc/terms/",
+    "data": {
+      "@id": "cr:data",
+      "@type": "@json"
+    },
+    "dataType": {
+      "@id": "cr:dataType",
+      "@type": "@vocab"
+    },
+    "examples": {
+      "@id": "cr:examples",
+      "@type": "@json"
+    }
+  },
+  "@type": "sc:Dataset",
+  "name": "Linalg-Spec-30",
+  "description": "Hand-authored NL\u2192MLIR pairs for linalg named ops under memref semantics (matmul, matvec, fill, copy, transpose, broadcast, add, sub, mul, div, exp, abs).",
+  "conformsTo": "http://mlcommons.org/croissant/1.0",
+  "license": "https://spdx.org/licenses/Apache-2.0.html",
+  "version": "1.0.0",
+  "datePublished": "2026-04-21",
+  "citeAs": "(anonymous submission to NeurIPS 2026 E&D track)",
+  "url": "<populated-at-camera-ready>",
+  "distribution": [
+    {
+      "@type": "cr:FileObject",
+      "@id": "Linalg-Spec-30-archive",
+      "name": "Linalg-Spec-30.zip",
+      "contentUrl": "<populated-at-camera-ready>",
+      "encodingFormat": "application/zip",
+      "sha256": "<populated-at-camera-ready>"
+    }
+  ],
+  "recordSet": [
+    {
+      "@type": "cr:RecordSet",
+      "@id": "records",
+      "name": "records",
+      "description": "One MLIR prompt/reference pair per record.",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "records/id",
+          "name": "id",
+          "dataType": "sc:Text",
+          "description": "Unique record identifier."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "records/nl",
+          "name": "nl",
+          "dataType": "sc:Text",
+          "description": "Natural-language description."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "records/mlir",
+          "name": "mlir",
+          "dataType": "sc:Text",
+          "description": "Reference MLIR that verifies under mlir-opt/iree-compile."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "records/dialect",
+          "name": "dialect",
+          "dataType": "sc:Text",
+          "description": "MLIR dialect of the reference program."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "records/difficulty",
+          "name": "difficulty",
+          "dataType": "sc:Text",
+          "description": "Author-assigned difficulty or 'programmatic'."
+        }
+      ]
+    }
+  ],
+  "rai:dataCollection": "Hand-authored by the submitting author against the target MLIR dialect's ODS.",
+  "rai:dataBiases": [
+    "Author-curated: prompts reflect the submitting author's mental model of the target dialect; may under-represent op combinations not present in the spec examples.",
+    "No human-subject data; no PII; no demographic bias dimensions apply."
+  ],
+  "rai:dataLimitations": [
+    "Verify-valid pass-rate measures structural validity under mlir-opt/iree-compile, not functional correctness. Programs that pass the gate may still compute the wrong function.",
+    "English natural-language descriptions only.",
+    "Small n (30-200 prompts per dataset) yields CI half-widths of ~3-10pp at p=0.5."
+  ],
+  "rai:annotationsPerExample": 0,
+  "rai:annotationDemographics": "N/A \u2014 no human annotators.",
+  "rai:personalSensitiveInformation": "None.",
+  "rai:useCases": [
+    "Evaluating NL\u2192MLIR generation systems (constrained or unconstrained) under a verifier-based pass-rate metric."
+  ],
+  "rai:excludedUseCases": [
+    "Evaluating functional correctness without an additional lowering + execution harness.",
+    "Training or fine-tuning production code-generation models without a separate held-out corpus."
+  ],
+  "extra": {
+    "size": 30,
+    "sampling": "Author-curated (single author), 12 linalg named ops."
+  }
+}

data/test.jsonl

@@ -0,0 +1,30 @@
+{"id": "01_matmul-dynamic", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that performs a matrix multiplication of two 2-D f32 memrefs with dynamic shapes and writes the result into a pre-allocated output memref.", "mlir": "module {\n  func.func @mm(%A: memref<?x?xf32>, %B: memref<?x?xf32>, %C: memref<?x?xf32>) {\n    linalg.matmul ins(%A, %B : memref<?x?xf32>, memref<?x?xf32>) outs(%C : memref<?x?xf32>)\n    return\n  }\n}\n", "notes": "canonical linalg.matmul"}
+{"id": "02_matmul-static-2x2", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that performs a 2x2 matrix multiplication of f32 matrices. All inputs are statically-shaped memrefs.", "mlir": "module {\n  func.func @mm22(%A: memref<2x2xf32>, %B: memref<2x2xf32>, %C: memref<2x2xf32>) {\n    linalg.matmul ins(%A, %B : memref<2x2xf32>, memref<2x2xf32>) outs(%C : memref<2x2xf32>)\n    return\n  }\n}\n", "notes": "static-shape matmul"}
+{"id": "03_matmul-rectangular", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that multiplies a 4x8xf32 matrix by an 8x2xf32 matrix, writing to a 4x2xf32 result memref.", "mlir": "module {\n  func.func @mm482(%A: memref<4x8xf32>, %B: memref<8x2xf32>, %C: memref<4x2xf32>) {\n    linalg.matmul ins(%A, %B : memref<4x8xf32>, memref<8x2xf32>) outs(%C : memref<4x2xf32>)\n    return\n  }\n}\n", "notes": "rectangular MxK * KxN"}
+{"id": "04_matmul-f64", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that performs matmul on two f64 2-D memrefs into an f64 output memref.", "mlir": "module {\n  func.func @mmf64(%A: memref<?x?xf64>, %B: memref<?x?xf64>, %C: memref<?x?xf64>) {\n    linalg.matmul ins(%A, %B : memref<?x?xf64>, memref<?x?xf64>) outs(%C : memref<?x?xf64>)\n    return\n  }\n}\n", "notes": "f64 matmul"}
+{"id": "05_fill-matmul-chain", "dialect": "linalg+memref+arith+func", "difficulty": "hard", "nl": "Write a function that zeroes an f32 output memref using linalg.fill, then computes matmul of two input memrefs into it.", "mlir": "module {\n  func.func @fm(%A: memref<?x?xf32>, %B: memref<?x?xf32>, %C: memref<?x?xf32>) {\n    %z = arith.constant 0.0 : f32\n    linalg.fill ins(%z : f32) outs(%C : memref<?x?xf32>)\n    linalg.matmul ins(%A, %B : memref<?x?xf32>, memref<?x?xf32>) outs(%C : memref<?x?xf32>)\n    return\n  }\n}\n", "notes": "zero-then-matmul idiom"}
+{"id": "06_fill-zero-1d", "dialect": "linalg+memref+arith+func", "difficulty": "easy", "nl": "Write a function that fills a 1-D f32 memref with zeros.", "mlir": "module {\n  func.func @f0(%m: memref<?xf32>) {\n    %z = arith.constant 0.0 : f32\n    linalg.fill ins(%z : f32) outs(%m : memref<?xf32>)\n    return\n  }\n}\n", "notes": "zero-fill 1D"}
+{"id": "07_fill-value-param", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that fills a 2-D f32 memref with a given f32 value passed as a parameter.", "mlir": "module {\n  func.func @fp(%v: f32, %m: memref<?x?xf32>) {\n    linalg.fill ins(%v : f32) outs(%m : memref<?x?xf32>)\n    return\n  }\n}\n", "notes": "fill with parameter value"}
+{"id": "08_fill-i32", "dialect": "linalg+memref+arith+func", "difficulty": "easy", "nl": "Write a function that fills a 1-D i32 memref with the integer constant 7.", "mlir": "module {\n  func.func @f7(%m: memref<?xi32>) {\n    %c7 = arith.constant 7 : i32\n    linalg.fill ins(%c7 : i32) outs(%m : memref<?xi32>)\n    return\n  }\n}\n", "notes": "integer-typed fill"}
+{"id": "09_copy-1d", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that copies a 1-D f32 memref into another 1-D f32 memref of the same shape.", "mlir": "module {\n  func.func @c1(%s: memref<?xf32>, %d: memref<?xf32>) {\n    linalg.copy ins(%s : memref<?xf32>) outs(%d : memref<?xf32>)\n    return\n  }\n}\n", "notes": "1D copy"}
+{"id": "10_copy-2d-static", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that copies a 4x4xf32 static memref into another 4x4xf32 memref.", "mlir": "module {\n  func.func @c2(%s: memref<4x4xf32>, %d: memref<4x4xf32>) {\n    linalg.copy ins(%s : memref<4x4xf32>) outs(%d : memref<4x4xf32>)\n    return\n  }\n}\n", "notes": "2D static copy"}
+{"id": "11_copy-i32", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that copies a 1-D i32 memref into another 1-D i32 memref of the same shape.", "mlir": "module {\n  func.func @ci(%s: memref<?xi32>, %d: memref<?xi32>) {\n    linalg.copy ins(%s : memref<?xi32>) outs(%d : memref<?xi32>)\n    return\n  }\n}\n", "notes": "i32 copy"}
+{"id": "12_transpose-2d", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that transposes a 2-D f32 memref into another 2-D f32 memref using permutation [1, 0].", "mlir": "module {\n  func.func @t2(%s: memref<?x?xf32>, %d: memref<?x?xf32>) {\n    linalg.transpose ins(%s : memref<?x?xf32>) outs(%d : memref<?x?xf32>) permutation = [1, 0]\n    return\n  }\n}\n", "notes": "2D transpose"}
+{"id": "13_transpose-3d", "dialect": "linalg+memref+func", "difficulty": "hard", "nl": "Write a function that transposes a 3-D f32 memref using permutation [0, 2, 1] (swap the last two dimensions).", "mlir": "module {\n  func.func @t3(%s: memref<?x?x?xf32>, %d: memref<?x?x?xf32>) {\n    linalg.transpose ins(%s : memref<?x?x?xf32>) outs(%d : memref<?x?x?xf32>) permutation = [0, 2, 1]\n    return\n  }\n}\n", "notes": "3D transpose"}
+{"id": "14_transpose-static", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that transposes a 3x5xf32 memref to a 5x3xf32 memref using permutation [1, 0].", "mlir": "module {\n  func.func @ts(%s: memref<3x5xf32>, %d: memref<5x3xf32>) {\n    linalg.transpose ins(%s : memref<3x5xf32>) outs(%d : memref<5x3xf32>) permutation = [1, 0]\n    return\n  }\n}\n", "notes": "static-shape transpose"}
+{"id": "15_broadcast-1d-to-2d", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that broadcasts a 1-D f32 memref to a 2-D f32 memref along the 0th dimension.", "mlir": "module {\n  func.func @b1(%s: memref<?xf32>, %d: memref<?x?xf32>) {\n    linalg.broadcast ins(%s : memref<?xf32>) outs(%d : memref<?x?xf32>) dimensions = [0]\n    return\n  }\n}\n", "notes": "1D to 2D broadcast, dim 0"}
+{"id": "16_broadcast-dim1", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that broadcasts a 1-D f32 memref to a 2-D f32 memref along the 1st dimension.", "mlir": "module {\n  func.func @b2(%s: memref<?xf32>, %d: memref<?x?xf32>) {\n    linalg.broadcast ins(%s : memref<?xf32>) outs(%d : memref<?x?xf32>) dimensions = [1]\n    return\n  }\n}\n", "notes": "1D to 2D broadcast, dim 1"}
+{"id": "17_matvec", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that performs a matrix-vector multiplication: input is a 2-D f32 memref and a 1-D f32 memref; output is a 1-D f32 memref.", "mlir": "module {\n  func.func @mv(%A: memref<?x?xf32>, %x: memref<?xf32>, %y: memref<?xf32>) {\n    linalg.matvec ins(%A, %x : memref<?x?xf32>, memref<?xf32>) outs(%y : memref<?xf32>)\n    return\n  }\n}\n", "notes": "canonical matvec"}
+{"id": "18_matvec-static", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that multiplies a 4x8xf32 matrix by an 8xf32 vector, writing to a 4xf32 result memref.", "mlir": "module {\n  func.func @mvs(%A: memref<4x8xf32>, %x: memref<8xf32>, %y: memref<4xf32>) {\n    linalg.matvec ins(%A, %x : memref<4x8xf32>, memref<8xf32>) outs(%y : memref<4xf32>)\n    return\n  }\n}\n", "notes": "static matvec 4x8 by 8"}
+{"id": "19_matvec-f64", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that performs a matvec on f64 inputs.", "mlir": "module {\n  func.func @mvd(%A: memref<?x?xf64>, %x: memref<?xf64>, %y: memref<?xf64>) {\n    linalg.matvec ins(%A, %x : memref<?x?xf64>, memref<?xf64>) outs(%y : memref<?xf64>)\n    return\n  }\n}\n", "notes": "f64 matvec"}
+{"id": "20_add-elemwise", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that adds two 1-D f32 memrefs element-wise into a third output memref.", "mlir": "module {\n  func.func @ae(%a: memref<?xf32>, %b: memref<?xf32>, %c: memref<?xf32>) {\n    linalg.add ins(%a, %b : memref<?xf32>, memref<?xf32>) outs(%c : memref<?xf32>)\n    return\n  }\n}\n", "notes": "elemwise add"}
+{"id": "21_sub-elemwise", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that subtracts two 1-D f32 memrefs element-wise.", "mlir": "module {\n  func.func @se(%a: memref<?xf32>, %b: memref<?xf32>, %c: memref<?xf32>) {\n    linalg.sub ins(%a, %b : memref<?xf32>, memref<?xf32>) outs(%c : memref<?xf32>)\n    return\n  }\n}\n", "notes": "elemwise sub"}
+{"id": "22_mul-elemwise-2d", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that multiplies two 2-D f32 memrefs element-wise (Hadamard product) into an output memref.", "mlir": "module {\n  func.func @me(%a: memref<?x?xf32>, %b: memref<?x?xf32>, %c: memref<?x?xf32>) {\n    linalg.mul ins(%a, %b : memref<?x?xf32>, memref<?x?xf32>) outs(%c : memref<?x?xf32>)\n    return\n  }\n}\n", "notes": "Hadamard product"}
+{"id": "23_div-elemwise", "dialect": "linalg+memref+func", "difficulty": "medium", "nl": "Write a function that divides two 1-D f32 memrefs element-wise.", "mlir": "module {\n  func.func @de(%a: memref<?xf32>, %b: memref<?xf32>, %c: memref<?xf32>) {\n    linalg.div ins(%a, %b : memref<?xf32>, memref<?xf32>) outs(%c : memref<?xf32>)\n    return\n  }\n}\n", "notes": "elemwise div"}
+{"id": "24_exp-elemwise", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that applies the elementwise exponential to a 1-D f32 memref, writing the result into another memref.", "mlir": "module {\n  func.func @ee(%x: memref<?xf32>, %y: memref<?xf32>) {\n    linalg.exp ins(%x : memref<?xf32>) outs(%y : memref<?xf32>)\n    return\n  }\n}\n", "notes": "elemwise exp"}
+{"id": "25_exp-2d", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that applies elementwise exp to a 2-D f32 memref, writing into an output memref of the same shape.", "mlir": "module {\n  func.func @e2(%x: memref<?x?xf32>, %y: memref<?x?xf32>) {\n    linalg.exp ins(%x : memref<?x?xf32>) outs(%y : memref<?x?xf32>)\n    return\n  }\n}\n", "notes": "2D exp"}
+{"id": "26_abs-elemwise", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that applies the elementwise absolute value to a 1-D f32 memref, writing the result into another memref.", "mlir": "module {\n  func.func @ae(%x: memref<?xf32>, %y: memref<?xf32>) {\n    linalg.abs ins(%x : memref<?xf32>) outs(%y : memref<?xf32>)\n    return\n  }\n}\n", "notes": "elemwise abs"}
+{"id": "27_abs-2d", "dialect": "linalg+memref+func", "difficulty": "easy", "nl": "Write a function that applies elementwise abs to a 2-D f32 memref.", "mlir": "module {\n  func.func @a2(%x: memref<?x?xf32>, %y: memref<?x?xf32>) {\n    linalg.abs ins(%x : memref<?x?xf32>) outs(%y : memref<?x?xf32>)\n    return\n  }\n}\n", "notes": "2D abs"}
+{"id": "28_fill-then-copy", "dialect": "linalg+memref+arith+func", "difficulty": "hard", "nl": "Write a function that fills a 1-D f32 memref with 1.0 and then copies its contents into a second memref.", "mlir": "module {\n  func.func @fc(%m: memref<?xf32>, %d: memref<?xf32>) {\n    %one = arith.constant 1.0 : f32\n    linalg.fill ins(%one : f32) outs(%m : memref<?xf32>)\n    linalg.copy ins(%m : memref<?xf32>) outs(%d : memref<?xf32>)\n    return\n  }\n}\n", "notes": "fill-then-copy chain"}
+{"id": "29_add-then-exp", "dialect": "linalg+memref+func", "difficulty": "hard", "nl": "Write a function that adds two 1-D f32 memrefs element-wise into a temporary buffer, then applies exp to the buffer into the final output.", "mlir": "module {\n  func.func @ax(%a: memref<?xf32>, %b: memref<?xf32>, %t: memref<?xf32>, %y: memref<?xf32>) {\n    linalg.add ins(%a, %b : memref<?xf32>, memref<?xf32>) outs(%t : memref<?xf32>)\n    linalg.exp ins(%t : memref<?xf32>) outs(%y : memref<?xf32>)\n    return\n  }\n}\n", "notes": "add-then-exp chain"}
+{"id": "30_transpose-then-matmul", "dialect": "linalg+memref+func", "difficulty": "hard", "nl": "Write a function that transposes A (2-D f32) into a temp memref and then performs matmul of transposed A and B.", "mlir": "module {\n  func.func @tm(%A: memref<?x?xf32>, %At: memref<?x?xf32>, %B: memref<?x?xf32>, %C: memref<?x?xf32>) {\n    linalg.transpose ins(%A : memref<?x?xf32>) outs(%At : memref<?x?xf32>) permutation = [1, 0]\n    linalg.matmul ins(%At, %B : memref<?x?xf32>, memref<?x?xf32>) outs(%C : memref<?x?xf32>)\n    return\n  }\n}\n", "notes": "transpose-then-matmul"}