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,94 @@
+---
+license: apache-2.0
+language:
+- en
+pretty_name: StableHLO-Spec-30
+size_categories:
+- n<1K
+task_categories:
+- text-generation
+- text2text-generation
+tags:
+- mlir
+- code-generation
+- compiler
+- constrained-decoding
+- stablehlo
+configs:
+- config_name: default
+  data_files:
+  - split: test
+    path: data/test.jsonl
+---
+
+# StableHLO-Spec-30
+
+Hand-authored NL→StableHLO pairs across 10 op families (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**: `stablehlo-opt v1.4.0` (upstream truth) and `iree-compile --compile-to=input` (substitute, 50/50 concordant on a stratified n=50 sample)
+- **License**: Apache-2.0 (SPDX: Apache-2.0). No third-party IP restrictions.
+
+## Loading
+
+```python
+from datasets import load_dataset
+ds = load_dataset("plawanrath/StableHLO-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": "StableHLO-Spec-30",
+  "description": "Hand-authored NL\u2192MLIR pairs for StableHLO dialect covering 10 op families.",
+  "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": "StableHLO-Spec-30-archive",
+      "name": "StableHLO-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), 10 op families."
+  }
+}

data/test.jsonl

@@ -0,0 +1,30 @@
+{"id": "01_add-1d", "difficulty": "easy", "nl": "Write a function that adds two 1-D f32 tensors of 16 elements using stablehlo.add.", "mlir": "module {\n  func.func @a(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {\n    %0 = stablehlo.add %a, %b : tensor<16xf32>\n    return %0 : tensor<16xf32>\n  }\n}", "notes": "canonical stablehlo.add", "dialect": "stablehlo+func"}
+{"id": "02_add-2d-dynamic", "difficulty": "easy", "nl": "Write a function that adds two 2-D f32 tensors with dynamic shapes and returns the result.", "mlir": "module {\n  func.func @add2d(%a: tensor<?x?xf32>, %b: tensor<?x?xf32>) -> tensor<?x?xf32> {\n    %0 = stablehlo.add %a, %b : tensor<?x?xf32>\n    return %0 : tensor<?x?xf32>\n  }\n}", "notes": "dynamic-shape addition", "dialect": "stablehlo+func"}
+{"id": "03_subtract-1d-i32", "difficulty": "easy", "nl": "Write a function that subtracts two 1-D i32 tensors elementwise.", "mlir": "module {\n  func.func @sub(%a: tensor<8xi32>, %b: tensor<8xi32>) -> tensor<8xi32> {\n    %0 = stablehlo.subtract %a, %b : tensor<8xi32>\n    return %0 : tensor<8xi32>\n  }\n}", "notes": "integer subtraction", "dialect": "stablehlo+func"}
+{"id": "04_multiply-2d", "difficulty": "easy", "nl": "Write a function that multiplies two 4x4 f32 tensors elementwise using stablehlo.multiply.", "mlir": "module {\n  func.func @mul(%a: tensor<4x4xf32>, %b: tensor<4x4xf32>) -> tensor<4x4xf32> {\n    %0 = stablehlo.multiply %a, %b : tensor<4x4xf32>\n    return %0 : tensor<4x4xf32>\n  }\n}", "notes": "static 4x4 multiply", "dialect": "stablehlo+func"}
+{"id": "05_divide-f64", "difficulty": "easy", "nl": "Write a function that divides two 1-D f64 tensors of 32 elements using stablehlo.divide.", "mlir": "module {\n  func.func @div(%a: tensor<32xf64>, %b: tensor<32xf64>) -> tensor<32xf64> {\n    %0 = stablehlo.divide %a, %b : tensor<32xf64>\n    return %0 : tensor<32xf64>\n  }\n}", "notes": "f64 division", "dialect": "stablehlo+func"}
+{"id": "06_abs-f32", "difficulty": "easy", "nl": "Write a function that computes the elementwise absolute value of a 1-D f32 tensor.", "mlir": "module {\n  func.func @ab(%a: tensor<16xf32>) -> tensor<16xf32> {\n    %0 = stablehlo.abs %a : tensor<16xf32>\n    return %0 : tensor<16xf32>\n  }\n}", "notes": "abs", "dialect": "stablehlo+func"}
+{"id": "07_exp-1d", "difficulty": "easy", "nl": "Write a function that computes the elementwise exponential of a 1-D f32 tensor of 10 elements.", "mlir": "module {\n  func.func @ex(%a: tensor<10xf32>) -> tensor<10xf32> {\n    %0 = stablehlo.exponential %a : tensor<10xf32>\n    return %0 : tensor<10xf32>\n  }\n}", "notes": "exp", "dialect": "stablehlo+func"}
+{"id": "08_abs-dynamic", "difficulty": "medium", "nl": "Write a function that computes the elementwise absolute value of a dynamic-shape 2-D f32 tensor.", "mlir": "module {\n  func.func @abd(%a: tensor<?x?xf32>) -> tensor<?x?xf32> {\n    %0 = stablehlo.abs %a : tensor<?x?xf32>\n    return %0 : tensor<?x?xf32>\n  }\n}", "notes": "dynamic abs", "dialect": "stablehlo+func"}
+{"id": "09_transpose-2d", "difficulty": "medium", "nl": "Write a function that transposes a 4x8 f32 tensor producing an 8x4 tensor.", "mlir": "module {\n  func.func @t(%a: tensor<4x8xf32>) -> tensor<8x4xf32> {\n    %0 = stablehlo.transpose %a, dims = [1, 0] : (tensor<4x8xf32>) -> tensor<8x4xf32>\n    return %0 : tensor<8x4xf32>\n  }\n}", "notes": "transpose 2D", "dialect": "stablehlo+func"}
+{"id": "10_transpose-3d", "difficulty": "medium", "nl": "Write a function that transposes a 2x3x4 f32 tensor with permutation [2, 0, 1] producing a 4x2x3 tensor.", "mlir": "module {\n  func.func @t3(%a: tensor<2x3x4xf32>) -> tensor<4x2x3xf32> {\n    %0 = stablehlo.transpose %a, dims = [2, 0, 1] : (tensor<2x3x4xf32>) -> tensor<4x2x3xf32>\n    return %0 : tensor<4x2x3xf32>\n  }\n}", "notes": "3D transpose", "dialect": "stablehlo+func"}
+{"id": "11_transpose-square", "difficulty": "easy", "nl": "Write a function that transposes a 3x3 f32 tensor.", "mlir": "module {\n  func.func @t(%a: tensor<3x3xf32>) -> tensor<3x3xf32> {\n    %0 = stablehlo.transpose %a, dims = [1, 0] : (tensor<3x3xf32>) -> tensor<3x3xf32>\n    return %0 : tensor<3x3xf32>\n  }\n}", "notes": "square transpose", "dialect": "stablehlo+func"}
+{"id": "12_broadcast-1d-to-2d", "difficulty": "medium", "nl": "Write a function that broadcasts a 1-D f32 tensor of 8 elements to a 4x8 2-D tensor along dimension 1.", "mlir": "module {\n  func.func @b(%a: tensor<8xf32>) -> tensor<4x8xf32> {\n    %0 = stablehlo.broadcast_in_dim %a, dims = [1] : (tensor<8xf32>) -> tensor<4x8xf32>\n    return %0 : tensor<4x8xf32>\n  }\n}", "notes": "broadcast 1D to 2D", "dialect": "stablehlo+func"}
+{"id": "13_broadcast-scalar-to-vector", "difficulty": "medium", "nl": "Write a function that broadcasts a scalar f32 (shape [1]) to a 1-D f32 tensor of 16 elements.", "mlir": "module {\n  func.func @bs(%a: tensor<1xf32>) -> tensor<16xf32> {\n    %0 = stablehlo.broadcast_in_dim %a, dims = [0] : (tensor<1xf32>) -> tensor<16xf32>\n    return %0 : tensor<16xf32>\n  }\n}", "notes": "scalar broadcast", "dialect": "stablehlo+func"}
+{"id": "14_reshape-flatten", "difficulty": "medium", "nl": "Write a function that flattens a 4x8 f32 tensor into a 1-D tensor of 32 elements.", "mlir": "module {\n  func.func @r(%a: tensor<4x8xf32>) -> tensor<32xf32> {\n    %0 = stablehlo.reshape %a : (tensor<4x8xf32>) -> tensor<32xf32>\n    return %0 : tensor<32xf32>\n  }\n}", "notes": "flatten", "dialect": "stablehlo+func"}
+{"id": "15_reshape-2d-to-3d", "difficulty": "medium", "nl": "Write a function that reshapes a 12x8 f32 tensor into a 3x4x8 3-D tensor.", "mlir": "module {\n  func.func @r(%a: tensor<12x8xf32>) -> tensor<3x4x8xf32> {\n    %0 = stablehlo.reshape %a : (tensor<12x8xf32>) -> tensor<3x4x8xf32>\n    return %0 : tensor<3x4x8xf32>\n  }\n}", "notes": "2D to 3D reshape", "dialect": "stablehlo+func"}
+{"id": "16_reshape-transpose-chain", "difficulty": "hard", "nl": "Write a function that flattens a 4x8 f32 tensor, then transposes the result — no wait, simpler: reshape a 4x8 tensor into 8x4.", "mlir": "module {\n  func.func @r(%a: tensor<4x8xf32>) -> tensor<8x4xf32> {\n    %0 = stablehlo.reshape %a : (tensor<4x8xf32>) -> tensor<8x4xf32>\n    return %0 : tensor<8x4xf32>\n  }\n}", "notes": "reshape shape change", "dialect": "stablehlo+func"}
+{"id": "17_dot_general-matmul", "difficulty": "medium", "nl": "Write a function that performs a matrix multiplication of a 4x8 f32 tensor and an 8x16 f32 tensor using stablehlo.dot_general.", "mlir": "module {\n  func.func @m(%a: tensor<4x8xf32>, %b: tensor<8x16xf32>) -> tensor<4x16xf32> {\n    %0 = stablehlo.dot_general %a, %b, contracting_dims = [1] x [0] : (tensor<4x8xf32>, tensor<8x16xf32>) -> tensor<4x16xf32>\n    return %0 : tensor<4x16xf32>\n  }\n}", "notes": "canonical matmul", "dialect": "stablehlo+func"}
+{"id": "18_dot_general-square", "difficulty": "medium", "nl": "Write a function that multiplies two 8x8 f32 tensors using stablehlo.dot_general.", "mlir": "module {\n  func.func @m(%a: tensor<8x8xf32>, %b: tensor<8x8xf32>) -> tensor<8x8xf32> {\n    %0 = stablehlo.dot_general %a, %b, contracting_dims = [1] x [0] : (tensor<8x8xf32>, tensor<8x8xf32>) -> tensor<8x8xf32>\n    return %0 : tensor<8x8xf32>\n  }\n}", "notes": "square matmul", "dialect": "stablehlo+func"}
+{"id": "19_dot_general-tall-thin", "difficulty": "medium", "nl": "Multiply a 128x16 f32 tensor by a 16x4 f32 tensor using stablehlo.dot_general.", "mlir": "module {\n  func.func @m(%a: tensor<128x16xf32>, %b: tensor<16x4xf32>) -> tensor<128x4xf32> {\n    %0 = stablehlo.dot_general %a, %b, contracting_dims = [1] x [0] : (tensor<128x16xf32>, tensor<16x4xf32>) -> tensor<128x4xf32>\n    return %0 : tensor<128x4xf32>\n  }\n}", "notes": "tall-thin matmul", "dialect": "stablehlo+func"}
+{"id": "20_add-multiply-chain", "difficulty": "medium", "nl": "Write a function that adds two 1-D f32 tensors and then multiplies the sum by the first input.", "mlir": "module {\n  func.func @c(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {\n    %0 = stablehlo.add %a, %b : tensor<16xf32>\n    %1 = stablehlo.multiply %0, %a : tensor<16xf32>\n    return %1 : tensor<16xf32>\n  }\n}", "notes": "add-then-multiply", "dialect": "stablehlo+func"}
+{"id": "21_abs-exp-chain", "difficulty": "medium", "nl": "Write a function that computes the exponential of the absolute value of a 1-D f32 tensor.", "mlir": "module {\n  func.func @c(%a: tensor<16xf32>) -> tensor<16xf32> {\n    %0 = stablehlo.abs %a : tensor<16xf32>\n    %1 = stablehlo.exponential %0 : tensor<16xf32>\n    return %1 : tensor<16xf32>\n  }\n}", "notes": "abs then exp", "dialect": "stablehlo+func"}
+{"id": "22_matmul-add-bias", "difficulty": "hard", "nl": "Matrix-multiply a 4x8 f32 tensor by an 8x16 f32 tensor, then add a 4x16 bias tensor.", "mlir": "module {\n  func.func @lin(%a: tensor<4x8xf32>, %b: tensor<8x16xf32>, %bias: tensor<4x16xf32>) -> tensor<4x16xf32> {\n    %0 = stablehlo.dot_general %a, %b, contracting_dims = [1] x [0] : (tensor<4x8xf32>, tensor<8x16xf32>) -> tensor<4x16xf32>\n    %1 = stablehlo.add %0, %bias : tensor<4x16xf32>\n    return %1 : tensor<4x16xf32>\n  }\n}", "notes": "linear layer", "dialect": "stablehlo+func"}
+{"id": "23_transpose-matmul", "difficulty": "hard", "nl": "Transpose a 8x4 f32 tensor, then matrix-multiply the result with a 4x16 f32 tensor.", "mlir": "module {\n  func.func @tm(%a: tensor<8x4xf32>, %b: tensor<8x16xf32>) -> tensor<4x16xf32> {\n    %0 = stablehlo.transpose %a, dims = [1, 0] : (tensor<8x4xf32>) -> tensor<4x8xf32>\n    %1 = stablehlo.dot_general %0, %b, contracting_dims = [1] x [0] : (tensor<4x8xf32>, tensor<8x16xf32>) -> tensor<4x16xf32>\n    return %1 : tensor<4x16xf32>\n  }\n}", "notes": "transpose+matmul", "dialect": "stablehlo+func"}
+{"id": "24_reshape-add", "difficulty": "medium", "nl": "Reshape a 4x4 f32 tensor into a 16-element 1-D tensor, then add to an existing 16-element tensor.", "mlir": "module {\n  func.func @ra(%a: tensor<4x4xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {\n    %0 = stablehlo.reshape %a : (tensor<4x4xf32>) -> tensor<16xf32>\n    %1 = stablehlo.add %0, %b : tensor<16xf32>\n    return %1 : tensor<16xf32>\n  }\n}", "notes": "reshape+add", "dialect": "stablehlo+func"}
+{"id": "25_broadcast-multiply", "difficulty": "hard", "nl": "Broadcast a length-8 1-D f32 tensor to a 4x8 tensor, then multiply with an existing 4x8 tensor.", "mlir": "module {\n  func.func @bm(%a: tensor<8xf32>, %b: tensor<4x8xf32>) -> tensor<4x8xf32> {\n    %0 = stablehlo.broadcast_in_dim %a, dims = [1] : (tensor<8xf32>) -> tensor<4x8xf32>\n    %1 = stablehlo.multiply %0, %b : tensor<4x8xf32>\n    return %1 : tensor<4x8xf32>\n  }\n}", "notes": "broadcast+multiply", "dialect": "stablehlo+func"}
+{"id": "26_add-3d", "difficulty": "easy", "nl": "Write a function that adds two 2x3x4 f32 tensors elementwise.", "mlir": "module {\n  func.func @a3(%a: tensor<2x3x4xf32>, %b: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {\n    %0 = stablehlo.add %a, %b : tensor<2x3x4xf32>\n    return %0 : tensor<2x3x4xf32>\n  }\n}", "notes": "3D add", "dialect": "stablehlo+func"}
+{"id": "27_subtract-bf16", "difficulty": "easy", "nl": "Write a function that subtracts two 16-element bf16 tensors elementwise.", "mlir": "module {\n  func.func @s(%a: tensor<16xbf16>, %b: tensor<16xbf16>) -> tensor<16xbf16> {\n    %0 = stablehlo.subtract %a, %b : tensor<16xbf16>\n    return %0 : tensor<16xbf16>\n  }\n}", "notes": "bf16 arithmetic", "dialect": "stablehlo+func"}
+{"id": "28_dot_general-f16", "difficulty": "medium", "nl": "Multiply two 16x16 f16 tensors using stablehlo.dot_general.", "mlir": "module {\n  func.func @m(%a: tensor<16x16xf16>, %b: tensor<16x16xf16>) -> tensor<16x16xf16> {\n    %0 = stablehlo.dot_general %a, %b, contracting_dims = [1] x [0] : (tensor<16x16xf16>, tensor<16x16xf16>) -> tensor<16x16xf16>\n    return %0 : tensor<16x16xf16>\n  }\n}", "notes": "f16 matmul", "dialect": "stablehlo+func"}
+{"id": "29_add-multiply-abs-chain", "difficulty": "hard", "nl": "Write a function that computes the absolute value of (a + b) * a for two 1-D f32 tensors.", "mlir": "module {\n  func.func @c(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {\n    %0 = stablehlo.add %a, %b : tensor<16xf32>\n    %1 = stablehlo.multiply %0, %a : tensor<16xf32>\n    %2 = stablehlo.abs %1 : tensor<16xf32>\n    return %2 : tensor<16xf32>\n  }\n}", "notes": "3-op chain", "dialect": "stablehlo+func"}
+{"id": "30_transpose-add", "difficulty": "medium", "nl": "Transpose a 4x4 f32 tensor then add it back to the original.", "mlir": "module {\n  func.func @ta(%a: tensor<4x4xf32>) -> tensor<4x4xf32> {\n    %0 = stablehlo.transpose %a, dims = [1, 0] : (tensor<4x4xf32>) -> tensor<4x4xf32>\n    %1 = stablehlo.add %0, %a : tensor<4x4xf32>\n    return %1 : tensor<4x4xf32>\n  }\n}", "notes": "symmetric sum", "dialect": "stablehlo+func"}