Upload Procedural Math Reasoning Robustness v1.0.0

CITATION.cff

@@ -0,0 +1,31 @@
+cff-version: 1.2.0
+message: If you use this dataset, please cite both the dataset and the accompanying paper.
+type: dataset
+title: 'Procedural Math Reasoning Robustness: dataset for "From Recognition to Reconstruction: Towards Robust Procedural Mathematical Reasoning"'
+version: 1.0.0
+date-released: '2026-11-12'
+license: CC-BY-SA-4.0
+authors: &id001
+- family-names: Mazdarani
+  given-names: Fateme
+  affiliation: Clemson University
+- family-names: Toxtli
+  given-names: Carlos
+  affiliation: Clemson University
+  orcid: https://orcid.org/0000-0002-9430-2661
+abstract: A procedural-robustness panel of 2,800 mathematical statements (1,400 equivalent reformulations of named theorems and 1,400 constructed contrasts) with reference theorem labels and ordered transformation sequences, 44,800 scored outputs from four open-weight models under four conditions (closed-book and retrieval-augmented), the retrieval corpora (306 theorem cards, 17 operation cards) and the full protocol (prompts, output schema, operation vocabulary and run settings).
+keywords:
+- mathematics
+- theorem-recognition
+- procedural-reasoning
+- retrieval-augmented-generation
+- robustness
+doi: 10.5281/zenodo.24179015
+url: https://huggingface.co/datasets/ai4he/procedural-math-reasoning-robustness
+preferred-citation:
+  type: conference-paper
+  title: 'From Recognition to Reconstruction: Towards Robust Procedural Mathematical Reasoning'
+  authors: *id001
+  year: 2026
+  collection-title: 4th Workshop on Mathematical Natural Language Processing (MathNLP 2026), EMNLP 2026
+  url: https://www.carlostoxtli.com/papers/mathnlp2026-from-recognition-to-reconstruction.pdf

LICENSE

@@ -0,0 +1,9 @@
+Creative Commons Attribution-ShareAlike 4.0 International
+
+Copyright (c) 2026 Fateme Mazdarani, Carlos Toxtli
+
+The data and documentation in this dataset are licensed under the Creative Commons Attribution-ShareAlike 4.0 International license.
+You may share and adapt them for any purpose, provided you give appropriate credit and distribute contributions under the same license.
+Full license text: https://creativecommons.org/licenses/by-sa/4.0/legalcode
+
+Theorem statements derive from the TREAT corpus, which is built from English Wikipedia (CC BY-SA 4.0); share-alike therefore applies.

README.md

@@ -0,0 +1,175 @@
+---
+license: cc-by-sa-4.0
+language:
+- en
+pretty_name: Procedural Math Reasoning Robustness
+size_categories:
+- 10K<n<100K
+task_categories:
+- text-classification
+- question-answering
+tags:
+- mathematics
+- theorem-recognition
+- procedural-reasoning
+- retrieval-augmented-generation
+- robustness
+configs:
+- config_name: results
+  data_files:
+  - split: train
+    path: results.csv
+  default: true
+- config_name: annotations
+  data_files:
+  - split: train
+    path: annotations.jsonl
+- config_name: items
+  data_files:
+  - split: train
+    path: items.jsonl
+- config_name: theorem_cards
+  data_files:
+  - split: train
+    path: retrieval/theorem_cards.jsonl
+- config_name: operation_cards
+  data_files:
+  - split: train
+    path: retrieval/operation_cards.jsonl
+---
+
+# Procedural Math Reasoning Robustness
+
+Dataset accompanying the paper *From Recognition to Reconstruction: Towards Robust Procedural Mathematical Reasoning* (4th Workshop on Mathematical Natural Language Processing (MathNLP 2026), EMNLP 2026).
+
+A procedural-robustness panel of 2,800 mathematical statements (1,400 equivalent reformulations of named theorems and 1,400 constructed contrasts) with reference theorem labels and ordered transformation sequences, 44,800 scored outputs from four open-weight models under four conditions (closed-book and retrieval-augmented), the retrieval corpora (306 theorem cards, 17 operation cards) and the full protocol (prompts, output schema, operation vocabulary and run settings).
+
+| | |
+|---|---|
+| **Paper** | [From Recognition to Reconstruction: Towards Robust Procedural Mathematical Reasoning](https://www.carlostoxtli.com/papers/mathnlp2026-from-recognition-to-reconstruction.pdf) |
+| **Venue** | 4th Workshop on Mathematical Natural Language Processing (MathNLP 2026), EMNLP 2026 |
+| **Authors** | Fateme Mazdarani, Carlos Toxtli |
+| **License** | Creative Commons Attribution-ShareAlike 4.0 International (`cc-by-sa-4.0`) |
+| **Dataset DOI** | [10.5281/zenodo.24179015](https://doi.org/10.5281/zenodo.24179015) |
+| **Version** | 1.0.0 |
+| **Maintainer** | [Human-AI Empowerment Lab, Clemson University](https://haielab.org) |
+
+## Paper abstract
+
+Mathematical reasoning systems should be consistent when the same concept is expressed in equivalent forms. This requires not only recognizing shared mathematical meaning but also identifying the representation changes and reconstructing a traceable route between forms. We study this problem through mathematical theorems, whose equivalent formulations preserve the same underlying result while differing substantially in representation. In this setting, theorem recognition is only the first step: a robust system must also identify the intervening transformations and recover their order. We introduce an evaluation of robust procedural mathematical reasoning with three components: theorem identification, transformation identification, and ordered reconstruction. Using validated theorem–representation pairs from an existing corpus, we build a procedural-robustness dataset with typed operations, reference procedures, and matched contrasts that distinguish valid reformulations from invalid ones. We first measure closed-book performance of four open-weight models to establish a baseline, then evaluate retrieval-augmented generation (RAG) as support mechanism for the same task. Models identify theorem identity more reliably than they recover the transformations and ordered routes connecting equivalent representations. RAG improves every stage, but procedural reconstruction remains the main bottleneck. The framework supports more consistent and traceable mathematical systems, with potential applications in mathematical search, tutoring, autoformalization, and scientific discovery.
+
+## Dataset structure
+
+| Path | Format | Size | Records |
+|---|---|---|---|
+| `README.txt` | txt | 1.9 KB |  |
+| `annotations.jsonl` | jsonl | 3.4 MB | 2,800 |
+| `items.jsonl` | jsonl | 645.2 KB | 2,800 |
+| `results.csv` | csv | 5.8 MB | 44,800 |
+| `protocol/decoder_output_schema.json` | json | 6.7 KB |  |
+| `protocol/decoder_system_prompt.txt` | txt | 1.3 KB |  |
+| `protocol/decoder_user_template.txt` | txt | 2.2 KB |  |
+| `protocol/executed_experiment_conditions.yaml` | yaml | 1.1 KB |  |
+| `protocol/operation_vocabulary.json` | json | 2.6 KB |  |
+| `retrieval/operation_cards.jsonl` | jsonl | 27.3 KB | 17 |
+| `retrieval/theorem_cards.jsonl` | jsonl | 299.8 KB | 306 |
+
+11 files, 10.2 MB in total (metadata files excluded). Records are rows for CSV/TSV/JSONL files and list length for JSON arrays.
+
+## Loading the data
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("ai4he/procedural-math-reasoning-robustness", "results")
+```
+
+Available subsets: `results`, `annotations`, `items`, `theorem_cards`, `operation_cards`. All other files can be downloaded with `huggingface_hub.snapshot_download` or from the Zenodo record.
+
+## Known limitations
+
+- Reference routes come from corpus metadata, not machine-checked proofs.
+- Contrasts were scored as negatives; their invalidity has not been independently established.
+- Results are unchanged from the original experiment, including 1,045 invalid outputs; raw generations and retry logs are not included.
+
+## Personal and sensitive information
+
+None.
+
+## License
+
+The data and documentation are released under the [Creative Commons Attribution-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-sa/4.0/). Theorem statements derive from the TREAT corpus, which is built from English Wikipedia (CC BY-SA 4.0); share-alike therefore applies.
+
+## Citation
+
+If you use this dataset, please cite the paper:
+
+```bibtex
+@inproceedings{Mazdarani2026Recognition,
+ title = {From Recognition to Reconstruction: Towards Robust Procedural Mathematical Reasoning},
+ author = {Mazdarani, Fateme and Toxtli, Carlos},
+ booktitle = {Proceedings of the 4th Workshop on Mathematical Natural Language Processing (MathNLP 2026)},
+ address = {Budapest, Hungary},
+ publisher = {Association for Computational Linguistics},
+ year = {2026},
+ month = October,
+ note = {Forthcoming},
+ url = {https://sites.google.com/view/mathnlp2026}
+}
+```
+
+and the dataset:
+
+```bibtex
+@dataset{Mazdarani2026ProceduralMathReasoningRData,
+  author = {Mazdarani, Fateme and Toxtli, Carlos},
+  title = {{Procedural Math Reasoning Robustness}: Dataset for ``From Recognition to Reconstruction: Towards Robust Procedural Mathematical Reasoning''},
+  year = {2026},
+  version = {1.0.0},
+  publisher = {Zenodo},
+  doi = {10.5281/zenodo.24179015},
+  url = {https://doi.org/10.5281/zenodo.24179015}
+}
+```
+
+## Notes from the original README.txt
+
+```text
+From Recognition to Reconstruction
+MathNLP 2026 data and results
+
+Fateme Mazdarani and Carlos Toxtli
+From Recognition to Reconstruction: Towards Robust Procedural Mathematical
+Reasoning. MathNLP 2026, pp. 42-56.
+
+Contents
+  items.jsonl          2,800 statements, paired IDs and inference order
+  annotations.jsonl    Reference theorem labels and transformation sequences
+  results.csv          44,800 scored outputs from four models and four conditions
+  retrieval/           306 theorem cards and 17 operation-card entries
+  protocol/            Prompts, output schema, operation vocabulary and settings
+
+JSONL files contain one JSON record per line and use UTF-8. Join the statement
+and annotation files on item_id. The results column opaque_public_id refers to
+the same ID; pair_id links each reformulation to its constructed contrast.
+reference_operations gives the ordered operation labels, and reference_route
+contains the source expressions and steps. Empty references for a contrast
+mean that no theorem match was supplied, not that non-equivalence was proved.
+
+The panel has 1,400 source reformulations and 1,400 constructed contrasts.
+Reference routes come from corpus metadata, not machine-checked proofs.
+The contrasts were scored as negative in the experiment; their invalidity
+and absence of another matching theorem have not been independently established.
+Some theorem assumptions are abbreviated in the source. The annotations and
+results should be interpreted with these limitations.
+
+Results are unchanged from the original experiment, including 1,045 invalid
+outputs. hidden_label records the original positive/negative class. Accuracy
+fields are binary indicators; compare positive examples and contrasts separately.
+Raw generations and retry logs are not included.
+
+Please cite the paper when using these materials. Existing rights and any
+third-party terms still apply; this archive grants no additional reuse license.
+```
+
+<!-- generated-by: _publishing/generate_metadata.py (full card) -->

README.txt

@@ -0,0 +1,35 @@
+From Recognition to Reconstruction
+MathNLP 2026 data and results
+
+Fateme Mazdarani and Carlos Toxtli
+From Recognition to Reconstruction: Towards Robust Procedural Mathematical
+Reasoning. MathNLP 2026, pp. 42-56.
+
+Contents
+  items.jsonl          2,800 statements, paired IDs and inference order
+  annotations.jsonl    Reference theorem labels and transformation sequences
+  results.csv          44,800 scored outputs from four models and four conditions
+  retrieval/           306 theorem cards and 17 operation-card entries
+  protocol/            Prompts, output schema, operation vocabulary and settings
+
+JSONL files contain one JSON record per line and use UTF-8. Join the statement
+and annotation files on item_id. The results column opaque_public_id refers to
+the same ID; pair_id links each reformulation to its constructed contrast.
+reference_operations gives the ordered operation labels, and reference_route
+contains the source expressions and steps. Empty references for a contrast
+mean that no theorem match was supplied, not that non-equivalence was proved.
+
+The panel has 1,400 source reformulations and 1,400 constructed contrasts.
+Reference routes come from corpus metadata, not machine-checked proofs.
+The contrasts were scored as negative in the experiment; their invalidity
+and absence of another matching theorem have not been independently established.
+Some theorem assumptions are abbreviated in the source. The annotations and
+results should be interpreted with these limitations.
+
+Results are unchanged from the original experiment, including 1,045 invalid
+outputs. hidden_label records the original positive/negative class. Accuracy
+fields are binary indicators; compare positive examples and contrasts separately.
+Raw generations and retry logs are not included.
+
+Please cite the paper when using these materials. Existing rights and any
+third-party terms still apply; this archive grants no additional reuse license.

croissant.json

@@ -0,0 +1,1158 @@
+{
+ "@context": {
+  "@language": "en",
+  "@vocab": "https://schema.org/",
+  "citeAs": "cr:citeAs",
+  "column": "cr:column",
+  "conformsTo": "dct:conformsTo",
+  "cr": "http://mlcommons.org/croissant/",
+  "rai": "http://mlcommons.org/croissant/RAI/",
+  "data": {
+   "@id": "cr:data",
+   "@type": "@json"
+  },
+  "dataType": {
+   "@id": "cr:dataType",
+   "@type": "@vocab"
+  },
+  "dct": "http://purl.org/dc/terms/",
+  "examples": {
+   "@id": "cr:examples",
+   "@type": "@json"
+  },
+  "extract": "cr:extract",
+  "field": "cr:field",
+  "fileProperty": "cr:fileProperty",
+  "fileObject": "cr:fileObject",
+  "fileSet": "cr:fileSet",
+  "format": "cr:format",
+  "includes": "cr:includes",
+  "isLiveDataset": "cr:isLiveDataset",
+  "jsonPath": "cr:jsonPath",
+  "key": "cr:key",
+  "md5": "cr:md5",
+  "parentField": "cr:parentField",
+  "path": "cr:path",
+  "recordSet": "cr:recordSet",
+  "references": "cr:references",
+  "regex": "cr:regex",
+  "repeated": "cr:repeated",
+  "replace": "cr:replace",
+  "sc": "https://schema.org/",
+  "separator": "cr:separator",
+  "source": "cr:source",
+  "subField": "cr:subField",
+  "transform": "cr:transform"
+ },
+ "@type": "sc:Dataset",
+ "conformsTo": "http://mlcommons.org/croissant/1.0",
+ "name": "Procedural Math Reasoning Robustness",
+ "alternateName": [
+  "procedural-math-reasoning-robustness"
+ ],
+ "description": "A procedural-robustness panel of 2,800 mathematical statements (1,400 equivalent reformulations of named theorems and 1,400 constructed contrasts) with reference theorem labels and ordered transformation sequences, 44,800 scored outputs from four open-weight models under four conditions (closed-book and retrieval-augmented), the retrieval corpora (306 theorem cards, 17 operation cards) and the full protocol (prompts, output schema, operation vocabulary and run settings).",
+ "url": "https://doi.org/10.5281/zenodo.24179015",
+ "sameAs": [
+  "https://huggingface.co/datasets/ai4he/procedural-math-reasoning-robustness",
+  "https://www.carlostoxtli.com/papers/mathnlp2026-from-recognition-to-reconstruction.pdf"
+ ],
+ "license": "https://creativecommons.org/licenses/by-sa/4.0/",
+ "version": "1.0.0",
+ "datePublished": "2026-11-12",
+ "inLanguage": "en",
+ "isLiveDataset": false,
+ "keywords": [
+  "mathematics",
+  "theorem-recognition",
+  "procedural-reasoning",
+  "retrieval-augmented-generation",
+  "robustness"
+ ],
+ "creator": [
+  {
+   "@type": "sc:Person",
+   "name": "Fateme Mazdarani",
+   "affiliation": {
+    "@type": "sc:Organization",
+    "name": "Clemson University"
+   }
+  },
+  {
+   "@type": "sc:Person",
+   "name": "Carlos Toxtli",
+   "affiliation": {
+    "@type": "sc:Organization",
+    "name": "Clemson University"
+   },
+   "identifier": "https://orcid.org/0000-0002-9430-2661"
+  }
+ ],
+ "citeAs": "@inproceedings{Mazdarani2026Recognition,\n title = {From Recognition to Reconstruction: Towards Robust Procedural Mathematical Reasoning},\n author = {Mazdarani, Fateme and Toxtli, Carlos},\n booktitle = {Proceedings of the 4th Workshop on Mathematical Natural Language Processing (MathNLP 2026)},\n address = {Budapest, Hungary},\n publisher = {Association for Computational Linguistics},\n year = {2026},\n month = October,\n note = {Forthcoming},\n url = {https://sites.google.com/view/mathnlp2026}\n}",
+ "distribution": [
+  {
+   "@type": "cr:FileObject",
+   "@id": "README.txt",
+   "name": "README.txt",
+   "contentUrl": "README.txt",
+   "contentSize": "1942 B",
+   "encodingFormat": "text/plain",
+   "sha256": "2905563cd81b433aecde432c050cd3b9bafee1ae6f46aef6ff39fe40d39372d8"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "annotations.jsonl",
+   "name": "annotations.jsonl",
+   "contentUrl": "annotations.jsonl",
+   "contentSize": "3540264 B",
+   "encodingFormat": "application/jsonlines",
+   "sha256": "babcd0410ff7ec9a1afdb84c1319596f58a2162e00e264d656bdd1d1f51654f5"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "items.jsonl",
+   "name": "items.jsonl",
+   "contentUrl": "items.jsonl",
+   "contentSize": "660656 B",
+   "encodingFormat": "application/jsonlines",
+   "sha256": "8c16480db786ee81621da746890bb2bea24f3109c3ccc08abb27a9f9b0061089"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "results.csv",
+   "name": "results.csv",
+   "contentUrl": "results.csv",
+   "contentSize": "6129122 B",
+   "encodingFormat": "text/csv",
+   "sha256": "eae0a9a95d7187d06ae9f7907a4d531ae56a1ebbf61d89953310fc8738fab617"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "protocol/decoder_output_schema.json",
+   "name": "protocol/decoder_output_schema.json",
+   "contentUrl": "protocol/decoder_output_schema.json",
+   "contentSize": "6870 B",
+   "encodingFormat": "application/json",
+   "sha256": "d68b5b9ac27cefeefd92f12a8a0c179c57bca17f01d0b79d29ed7b77467a9383"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "protocol/decoder_system_prompt.txt",
+   "name": "protocol/decoder_system_prompt.txt",
+   "contentUrl": "protocol/decoder_system_prompt.txt",
+   "contentSize": "1345 B",
+   "encodingFormat": "text/plain",
+   "sha256": "0a080f8e2e0b58669fa9faf9d945112545d1dc531ead5d1ae259199bf080921a"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "protocol/decoder_user_template.txt",
+   "name": "protocol/decoder_user_template.txt",
+   "contentUrl": "protocol/decoder_user_template.txt",
+   "contentSize": "2214 B",
+   "encodingFormat": "text/plain",
+   "sha256": "c58c11a61466cdd0e220ad3398f84ff58dea4ffdbca9b54fa36388c0a9f69d5b"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "protocol/executed_experiment_conditions.yaml",
+   "name": "protocol/executed_experiment_conditions.yaml",
+   "contentUrl": "protocol/executed_experiment_conditions.yaml",
+   "contentSize": "1099 B",
+   "encodingFormat": "application/yaml",
+   "sha256": "a4e8c5741e07a5183b70d3bafb5957fbfc0a8847aeabeabd1f8a4c6ff3a1bd45"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "protocol/operation_vocabulary.json",
+   "name": "protocol/operation_vocabulary.json",
+   "contentUrl": "protocol/operation_vocabulary.json",
+   "contentSize": "2691 B",
+   "encodingFormat": "application/json",
+   "sha256": "de175d37c1b5e8317ae61ad9893cf1536519a62e1ef660a8d00172f076b2d240"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "retrieval/operation_cards.jsonl",
+   "name": "retrieval/operation_cards.jsonl",
+   "contentUrl": "retrieval/operation_cards.jsonl",
+   "contentSize": "27920 B",
+   "encodingFormat": "application/jsonlines",
+   "sha256": "02c4d1339739b3fd5520735fafef957e35ebc4324c5dcffe03e67d659ab3a7c0"
+  },
+  {
+   "@type": "cr:FileObject",
+   "@id": "retrieval/theorem_cards.jsonl",
+   "name": "retrieval/theorem_cards.jsonl",
+   "contentUrl": "retrieval/theorem_cards.jsonl",
+   "contentSize": "306946 B",
+   "encodingFormat": "application/jsonlines",
+   "sha256": "3267a2117b0321e82a8b4db82b5d6d91573c8661c2f4965ce3d300cbe18fa075"
+  }
+ ],
+ "recordSet": [
+  {
+   "@type": "cr:RecordSet",
+   "@id": "results",
+   "name": "results",
+   "description": "Records from results.csv (44,800 rows).",
+   "field": [
+    {
+     "@type": "cr:Field",
+     "@id": "results/model_id",
+     "name": "model_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "model_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/condition_id",
+     "name": "condition_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "condition_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/opaque_public_id",
+     "name": "opaque_public_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "opaque_public_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/hidden_label",
+     "name": "hidden_label",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "hidden_label"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/terminal_status",
+     "name": "terminal_status",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "terminal_status"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/decision",
+     "name": "decision",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "decision"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/malformed",
+     "name": "malformed",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "malformed"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/theorem_exact",
+     "name": "theorem_exact",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "theorem_exact"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/route_exact",
+     "name": "route_exact",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "route_exact"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/joint_exact",
+     "name": "joint_exact",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "joint_exact"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/positive_accept",
+     "name": "positive_accept",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "positive_accept"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/false_positive",
+     "name": "false_positive",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "false_positive"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/true_negative",
+     "name": "true_negative",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "true_negative"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/negative_abstain",
+     "name": "negative_abstain",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "negative_abstain"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/prompt_leak_flags",
+     "name": "prompt_leak_flags",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "prompt_leak_flags"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/schema_errors",
+     "name": "schema_errors",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "schema_errors"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/predicted_ops_json",
+     "name": "predicted_ops_json",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "predicted_ops_json"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/gold_ops_json",
+     "name": "gold_ops_json",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "gold_ops_json"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/gold_theorem_name",
+     "name": "gold_theorem_name",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "gold_theorem_name"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "results/predicted_theorem_name",
+     "name": "predicted_theorem_name",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "results.csv"
+      },
+      "extract": {
+       "column": "predicted_theorem_name"
+      }
+     }
+    }
+   ]
+  },
+  {
+   "@type": "cr:RecordSet",
+   "@id": "annotations",
+   "name": "annotations",
+   "description": "Records from annotations.jsonl (2,800 rows). Nested fields not described here: reference_theorem, reference_operations, reference_route.",
+   "field": [
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/schema_version",
+     "name": "schema_version",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "schema_version"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/item_id",
+     "name": "item_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "item_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/item_role",
+     "name": "item_role",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "item_role"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/original_experiment_label",
+     "name": "original_experiment_label",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "original_experiment_label"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/annotation_basis",
+     "name": "annotation_basis",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "annotation_basis"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/semantic_certification",
+     "name": "semantic_certification",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "semantic_certification"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/family",
+     "name": "family",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "family"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/field",
+     "name": "field",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "field"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/subfield",
+     "name": "subfield",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "subfield"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/primary_mechanism",
+     "name": "primary_mechanism",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "primary_mechanism"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/transformation_category",
+     "name": "transformation_category",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "transformation_category"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/contrast_recipe",
+     "name": "contrast_recipe",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "contrast_recipe"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/corruption_location",
+     "name": "corruption_location",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "corruption_location"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "annotations/source_equivalence_identity",
+     "name": "source_equivalence_identity",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "annotations.jsonl"
+      },
+      "extract": {
+       "column": "source_equivalence_identity"
+      }
+     }
+    }
+   ]
+  },
+  {
+   "@type": "cr:RecordSet",
+   "@id": "items",
+   "name": "items",
+   "description": "Records from items.jsonl (2,800 rows).",
+   "field": [
+    {
+     "@type": "cr:Field",
+     "@id": "items/schema_version",
+     "name": "schema_version",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "items.jsonl"
+      },
+      "extract": {
+       "column": "schema_version"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "items/item_id",
+     "name": "item_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "items.jsonl"
+      },
+      "extract": {
+       "column": "item_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "items/pair_id",
+     "name": "pair_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "items.jsonl"
+      },
+      "extract": {
+       "column": "pair_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "items/statement_latex",
+     "name": "statement_latex",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "items.jsonl"
+      },
+      "extract": {
+       "column": "statement_latex"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "items/inference_order",
+     "name": "inference_order",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "items.jsonl"
+      },
+      "extract": {
+       "column": "inference_order"
+      }
+     }
+    }
+   ]
+  },
+  {
+   "@type": "cr:RecordSet",
+   "@id": "retrieval_theorem_cards",
+   "name": "retrieval_theorem_cards",
+   "description": "Records from retrieval/theorem_cards.jsonl (306 rows). Nested fields not described here: accepted_aliases.",
+   "field": [
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/canonical_name",
+     "name": "canonical_name",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "canonical_name"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/canonical_statement",
+     "name": "canonical_statement",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "canonical_statement"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/card_id",
+     "name": "card_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "card_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/card_text",
+     "name": "card_text",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "card_text"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/field",
+     "name": "field",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "field"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/index_type",
+     "name": "index_type",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "index_type"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/required_assumptions",
+     "name": "required_assumptions",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "required_assumptions"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/sha256",
+     "name": "sha256",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "sha256"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/source",
+     "name": "source",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "source"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/subfield",
+     "name": "subfield",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "subfield"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/theorem_id",
+     "name": "theorem_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "theorem_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_theorem_cards/token_count_approx",
+     "name": "token_count_approx",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/theorem_cards.jsonl"
+      },
+      "extract": {
+       "column": "token_count_approx"
+      }
+     }
+    }
+   ]
+  },
+  {
+   "@type": "cr:RecordSet",
+   "@id": "retrieval_operation_cards",
+   "name": "retrieval_operation_cards",
+   "description": "Records from retrieval/operation_cards.jsonl (17 rows).",
+   "field": [
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/applicability_preconditions",
+     "name": "applicability_preconditions",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "applicability_preconditions"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/card_id",
+     "name": "card_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "card_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/card_text",
+     "name": "card_text",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "card_text"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/forbidden_application",
+     "name": "forbidden_application",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "forbidden_application"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/index_type",
+     "name": "index_type",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "index_type"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/input_types",
+     "name": "input_types",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "input_types"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/inverse_effect",
+     "name": "inverse_effect",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "inverse_effect"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/inverse_operation_id",
+     "name": "inverse_operation_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "inverse_operation_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/output_types",
+     "name": "output_types",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "output_types"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/rule_id",
+     "name": "rule_id",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "rule_id"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/sha256",
+     "name": "sha256",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "sha256"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/source",
+     "name": "source",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "source"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/surface_signature",
+     "name": "surface_signature",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "surface_signature"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/token_count_approx",
+     "name": "token_count_approx",
+     "dataType": "sc:Integer",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "token_count_approx"
+      }
+     }
+    },
+    {
+     "@type": "cr:Field",
+     "@id": "retrieval_operation_cards/valid_example",
+     "name": "valid_example",
+     "dataType": "sc:Text",
+     "source": {
+      "fileObject": {
+       "@id": "retrieval/operation_cards.jsonl"
+      },
+      "extract": {
+       "column": "valid_example"
+      }
+     }
+    }
+   ]
+  }
+ ]
+}

protocol/decoder_output_schema.json

@@ -0,0 +1,274 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://example.org/schemas/route-decoder-v2.0.json",
+  "title": "Route Decoder Output v2.0",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version",
+    "decision",
+    "theorem",
+    "route",
+    "rejection",
+    "evidence_used"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": "route-decoder-v2.0"
+    },
+    "decision": {
+      "type": "string",
+      "enum": [
+        "ACCEPT",
+        "REJECT",
+        "ABSTAIN"
+      ]
+    },
+    "theorem": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "name",
+        "canonical_statement_latex",
+        "assumptions_used",
+        "confidence"
+      ],
+      "properties": {
+        "id": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "maxLength": 160
+        },
+        "name": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "maxLength": 240
+        },
+        "canonical_statement_latex": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "maxLength": 3000
+        },
+        "assumptions_used": {
+          "type": "array",
+          "maxItems": 12,
+          "items": {
+            "type": "string",
+            "maxLength": 500
+          }
+        },
+        "confidence": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        }
+      }
+    },
+    "route": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "operations",
+        "steps",
+        "final_statement_latex",
+        "minimality",
+        "confidence"
+      ],
+      "properties": {
+        "operations": {
+          "type": "array",
+          "maxItems": 6,
+          "items": {
+            "type": "string",
+            "enum": [
+              "REMOVE_ARGMIN_ENCODING",
+              "REMOVE_CHARACTERIZATION_ENCODING",
+              "REMOVE_CONTAINMENT_ENCODING",
+              "REMOVE_CYLINDER_ENCODING",
+              "REMOVE_DISTANCE_ENCODING",
+              "REMOVE_FIBER_ENCODING",
+              "REMOVE_INTERSECTION_ENCODING",
+              "REMOVE_MONOTONE_ENCODING",
+              "REMOVE_OPTIMIZATION_ENCODING",
+              "REMOVE_PAIR_ENCODING",
+              "REMOVE_QUANTIFIER_ENCODING",
+              "REMOVE_SET_MEMBERSHIP_ENCODING",
+              "REMOVE_TRUTH_TABLE_ENCODING",
+              "REMOVE_WITNESS_ENCODING",
+              "DENORMALIZE_RELATION",
+              "EXPAND_ABBREVIATIONS",
+              "OTHER"
+            ]
+          }
+        },
+        "steps": {
+          "type": "array",
+          "maxItems": 6,
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "index",
+              "operation",
+              "operation_free_text",
+              "input_latex",
+              "output_latex",
+              "rule_id",
+              "justification",
+              "confidence"
+            ],
+            "properties": {
+              "index": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 6
+              },
+              "operation": {
+                "type": "string",
+                "enum": [
+                  "REMOVE_ARGMIN_ENCODING",
+                  "REMOVE_CHARACTERIZATION_ENCODING",
+                  "REMOVE_CONTAINMENT_ENCODING",
+                  "REMOVE_CYLINDER_ENCODING",
+                  "REMOVE_DISTANCE_ENCODING",
+                  "REMOVE_FIBER_ENCODING",
+                  "REMOVE_INTERSECTION_ENCODING",
+                  "REMOVE_MONOTONE_ENCODING",
+                  "REMOVE_OPTIMIZATION_ENCODING",
+                  "REMOVE_PAIR_ENCODING",
+                  "REMOVE_QUANTIFIER_ENCODING",
+                  "REMOVE_SET_MEMBERSHIP_ENCODING",
+                  "REMOVE_TRUTH_TABLE_ENCODING",
+                  "REMOVE_WITNESS_ENCODING",
+                  "DENORMALIZE_RELATION",
+                  "EXPAND_ABBREVIATIONS",
+                  "OTHER"
+                ]
+              },
+              "operation_free_text": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "maxLength": 240
+              },
+              "input_latex": {
+                "type": "string",
+                "maxLength": 2400
+              },
+              "output_latex": {
+                "type": "string",
+                "maxLength": 2400
+              },
+              "rule_id": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "maxLength": 120
+              },
+              "justification": {
+                "type": "string",
+                "maxLength": 500
+              },
+              "confidence": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1
+              }
+            }
+          }
+        },
+        "final_statement_latex": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "maxLength": 3000
+        },
+        "minimality": {
+          "type": "string",
+          "enum": [
+            "MINIMAL",
+            "NON_MINIMAL",
+            "UNKNOWN"
+          ]
+        },
+        "confidence": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        }
+      }
+    },
+    "rejection": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "reason",
+        "failed_step_index",
+        "explanation"
+      ],
+      "properties": {
+        "reason": {
+          "type": "string",
+          "enum": [
+            "NONE",
+            "NO_THEOREM_MATCH",
+            "NOT_EQUIVALENT",
+            "INVALID_TRANSFORMATION",
+            "CONTRADICTED_ASSUMPTIONS",
+            "ILL_TYPED",
+            "AMBIGUOUS",
+            "INSUFFICIENT_EVIDENCE"
+          ]
+        },
+        "failed_step_index": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "minimum": 1,
+          "maximum": 6
+        },
+        "explanation": {
+          "type": "string",
+          "maxLength": 700
+        }
+      }
+    },
+    "evidence_used": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "theorem_card_ids",
+        "transform_rule_ids"
+      ],
+      "properties": {
+        "theorem_card_ids": {
+          "type": "array",
+          "maxItems": 16,
+          "items": {
+            "type": "string",
+            "maxLength": 120
+          }
+        },
+        "transform_rule_ids": {
+          "type": "array",
+          "maxItems": 16,
+          "items": {
+            "type": "string",
+            "maxLength": 120
+          }
+        }
+      }
+    }
+  }
+}

protocol/decoder_system_prompt.txt

@@ -0,0 +1,18 @@
+You are a mathematical route decoder. The observed statement may be either:
+(1) a valid equivalence-preserving encoding of a canonical theorem, or
+(2) an adversarial negative that must be rejected.
+
+Do not assume the statement is valid. Use only transformations whose preconditions are satisfied. Retrieved theorem cards are hypotheses, not answers. Retrieved transformation cards are rules, not proof that a rule applies.
+
+Decision policy:
+- ACCEPT only when you can identify a theorem and give an ordered inverse route whose every step is valid and whose endpoint is the stated canonical theorem under the listed assumptions.
+- REJECT when the statement is contradicted, ill-typed, does not match a theorem, or requires an invalid transformation.
+- ABSTAIN only when the evidence is genuinely insufficient or ambiguous.
+
+Route policy:
+- Output only scored inverse operations. Do not include RESTATE_CANONICAL_THEOREM as a route operation.
+- For every operation, provide its input and output expression so the route can be executed and checked.
+- Use OTHER only when no registered operation applies, and describe it in operation_free_text.
+- A theorem name without a valid route is not sufficient for ACCEPT.
+
+Return exactly one JSON object conforming to route-decoder-v2.0. Do not output markdown, commentary, or text outside the JSON object.

protocol/decoder_user_template.txt

@@ -0,0 +1,62 @@
+OBSERVED_STATEMENT_LATEX:
+{{observed_statement_latex}}
+
+THEOREM_EVIDENCE:
+{{theorem_evidence_or_NONE}}
+
+TRANSFORMATION_EVIDENCE:
+{{transform_evidence_or_NONE}}
+
+REGISTERED_OPERATION_IDS:
+{{operation_id_list}}
+
+Use exactly the same decision standard whether evidence is present or NONE.
+Evidence cards are optional aids, not labels. If the statement is a valid
+encoding, accept only with a valid theorem-route reconstruction. If it is not
+valid, reject or abstain even when retrieved cards look related.
+
+CRITICAL ROUTE RULES:
+- route.operations must be an array of registered operation strings only.
+- Do not include RESTATE_CANONICAL_THEOREM in route.operations.
+- route.steps must have the same length and order as route.operations.
+- route.operations[i] must equal route.steps[i].operation.
+- Step indices must be 1, 2, 3, ... with no gaps.
+- Each step must chain: step i output_latex should be step i+1 input_latex.
+- If the decision is REJECT or ABSTAIN, use route.operations=[] and route.steps=[].
+- If a necessary operation is not registered, use OTHER and explain it in operation_free_text.
+- Keep every justification and rejection explanation concise, preferably under 35 words.
+- Do not include long derivations, prose proofs, or markdown.
+
+Return exactly one JSON object with this top-level shape:
+{
+  "schema_version": "route-decoder-v2.0",
+  "decision": "ACCEPT | REJECT | ABSTAIN",
+  "theorem": {
+    "id": null,
+    "name": null,
+    "canonical_statement_latex": null,
+    "assumptions_used": [],
+    "confidence": 0.0
+  },
+  "route": {
+    "operations": [],
+    "steps": [],
+    "final_statement_latex": null,
+    "minimality": "UNKNOWN",
+    "confidence": 0.0
+  },
+  "rejection": {
+    "reason": "NO_THEOREM_MATCH | NOT_EQUIVALENT | INVALID_TRANSFORMATION | CONTRADICTED_ASSUMPTIONS | ILL_TYPED | AMBIGUOUS | INSUFFICIENT_EVIDENCE | NONE",
+    "failed_step_index": null,
+    "explanation": ""
+  },
+  "evidence_used": {
+    "theorem_card_ids": [],
+    "transform_rule_ids": []
+  }
+}
+
+For ACCEPT, rejection.reason must be NONE. For REJECT or ABSTAIN, theorem and
+route may be null/empty, but all fields must still be present.
+
+Produce the route-decoder-v2.0 JSON object now. Do not output markdown.

protocol/executed_experiment_conditions.yaml

@@ -0,0 +1,39 @@
+# Executed C0-C3 experiment configuration used for the reported study
+experiment_id: mathnlp_reformulation_rag_v1
+evaluation_panel:
+  positive_items: 1400
+  paired_contrast_items: 1400
+  total_model_facing_inputs: 2800
+  theorem_identities: 306
+  mathematical_families: 5
+  transformation_signatures: 20
+retrieval:
+  theorem_index_documents: 306
+  operator_index_documents: 17
+  top_k_per_active_index: 8
+  scoring: lowercase_alphanumeric_token_overlap_divided_by_sqrt_document_length
+  tie_breaker: stable_document_id
+conditions:
+  C0_BASE: closed_book
+  C1_THEOREM_RAG: theorem_index_only
+  C2_TRANSFORM_RAG: operator_index_only
+  C3_HYBRID_RAG: theorem_and_operator_indexes
+generators:
+  - gemma-4-31b
+  - gptoss-120b
+  - gptoss-20b
+  - leanstral-2603
+decoding:
+  temperature: 0
+  top_p: 1
+  seed: 20260723
+  max_output_tokens: 2200
+run_accounting:
+  intended_records: 44800
+  completed_records: 44800
+  backend_failures: 0
+  schema_invalid_after_repair: 1045
+  invalid_outputs_retained_as_incorrect: true
+statistics:
+  hierarchical_bootstrap_repetitions: 10000
+  interval: 95_percent_percentile

protocol/operation_vocabulary.json

@@ -0,0 +1,74 @@
+{
+  "schema_version": "route-operations-v2.0",
+  "note": "RESTATE_CANONICAL_THEOREM is intentionally excluded from scored route operations; final restatement is captured separately.",
+  "operations": [
+    {
+      "id": "REMOVE_ARGMIN_ENCODING",
+      "description": "Invert an argmin/minimizer wrapper that encodes equality or projection."
+    },
+    {
+      "id": "REMOVE_CHARACTERIZATION_ENCODING",
+      "description": "Invert an equivalent limit, level-set, slack, or characterization statement."
+    },
+    {
+      "id": "REMOVE_CONTAINMENT_ENCODING",
+      "description": "Recover a scalar or relational statement from set containment."
+    },
+    {
+      "id": "REMOVE_CYLINDER_ENCODING",
+      "description": "Recover pointwise equality from equality of cylinders or sets of pairs."
+    },
+    {
+      "id": "REMOVE_DISTANCE_ENCODING",
+      "description": "Recover equality or membership from a zero-distance statement."
+    },
+    {
+      "id": "REMOVE_FIBER_ENCODING",
+      "description": "Recover equality from equality/identity of fibers or preimages."
+    },
+    {
+      "id": "REMOVE_INTERSECTION_ENCODING",
+      "description": "Recover equality from a diagonal or graph-intersection construction."
+    },
+    {
+      "id": "REMOVE_MONOTONE_ENCODING",
+      "description": "Invert a strictly monotone function applied to both sides of a relation."
+    },
+    {
+      "id": "REMOVE_OPTIMIZATION_ENCODING",
+      "description": "Invert a generic optimization, slack, or residual minimization wrapper."
+    },
+    {
+      "id": "REMOVE_PAIR_ENCODING",
+      "description": "Remove an ordered-pair or product-space encoding."
+    },
+    {
+      "id": "REMOVE_QUANTIFIER_ENCODING",
+      "description": "Invert a quantified characterization of equality or order."
+    },
+    {
+      "id": "REMOVE_SET_MEMBERSHIP_ENCODING",
+      "description": "Recover a relation from membership in a cone, interval, singleton, or set."
+    },
+    {
+      "id": "REMOVE_TRUTH_TABLE_ENCODING",
+      "description": "Remove double negation, tautological conjunction/disjunction, or Boolean encoding."
+    },
+    {
+      "id": "REMOVE_WITNESS_ENCODING",
+      "description": "Eliminate an existential witness that encodes a relation."
+    },
+    {
+      "id": "DENORMALIZE_RELATION",
+      "description": "Restore the conventional direction or side ordering of a relation."
+    },
+    {
+      "id": "EXPAND_ABBREVIATIONS",
+      "description": "Expand benchmark abbreviations or shorthand symbols into the canonical form."
+    },
+    {
+      "id": "OTHER",
+      "description": "A proposed inverse operation outside the registered vocabulary; must be described in operation_free_text."
+    }
+  ]
+}

retrieval/operation_cards.jsonl

@@ -0,0 +1,17 @@
+{"applicability_preconditions": "Both argmin expressions encode the same unique minimizer or equality target; the wrapper is not itself the theorem content.", "card_id": "TRULE_REMOVE_ARGMIN_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_ARGMIN_ENCODING\nregistered inverse-operation ID: REMOVE_ARGMIN_ENCODING\ndescription: Invert an argmin/minimizer wrapper that encodes equality or projection.\nsurface signature: argmin/minimizer equality or projection wrapper\ninput types: optimization expression over a dummy domain\noutput types: underlying equality or endpoint expression\napplicability preconditions: Both argmin expressions encode the same unique minimizer or equality target; the wrapper is not itself the theorem content.\ninverse effect: Remove the argmin/projection wrapper and recover the equality between the wrapped expressions.\nschematic valid example: argmin_z d(z, A) = argmin_z d(z, B) -> A = B\nforbidden application: Do not remove argmin when the optimization objective changes the solution set or when minimizers are non-unique and encode extra content.", "forbidden_application": "Do not remove argmin when the optimization objective changes the solution set or when minimizers are non-unique and encode extra content.", "index_type": "transform_rule", "input_types": "optimization expression over a dummy domain", "inverse_effect": "Remove the argmin/projection wrapper and recover the equality between the wrapped expressions.", "inverse_operation_id": "REMOVE_ARGMIN_ENCODING", "output_types": "underlying equality or endpoint expression", "rule_id": "TRULE_REMOVE_ARGMIN_ENCODING", "sha256": "71515475046abd3239477ee9df9af6bf1d948638ccab623e2744769c48ec1fcb", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "argmin/minimizer equality or projection wrapper", "token_count_approx": 112, "valid_example": "argmin_z d(z, A) = argmin_z d(z, B) -> A = B"}
+{"applicability_preconditions": "The characterization is bidirectionally equivalent under the stated assumptions.", "card_id": "TRULE_REMOVE_CHARACTERIZATION_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_CHARACTERIZATION_ENCODING\nregistered inverse-operation ID: REMOVE_CHARACTERIZATION_ENCODING\ndescription: Invert an equivalent limit, level-set, slack, or characterization statement.\nsurface signature: limit, level-set, slack, residual, or iff characterization\ninput types: equivalent characterization statement\noutput types: canonical relation or equation\napplicability preconditions: The characterization is bidirectionally equivalent under the stated assumptions.\ninverse effect: Replace the characterization by the canonical relation it characterizes.\nschematic valid example: x is the unique point with f(x)=0 -> f(x)=0 when uniqueness is irrelevant to the theorem endpoint\nforbidden application: Do not drop a one-way implication or an extra uniqueness/regularity condition that is not equivalent.", "forbidden_application": "Do not drop a one-way implication or an extra uniqueness/regularity condition that is not equivalent.", "index_type": "transform_rule", "input_types": "equivalent characterization statement", "inverse_effect": "Replace the characterization by the canonical relation it characterizes.", "inverse_operation_id": "REMOVE_CHARACTERIZATION_ENCODING", "output_types": "canonical relation or equation", "rule_id": "TRULE_REMOVE_CHARACTERIZATION_ENCODING", "sha256": "3522f1460de9961ae292a50e29d3dc5fc023842947cce665d311faeae0461e5f", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "limit, level-set, slack, residual, or iff characterization", "token_count_approx": 97, "valid_example": "x is the unique point with f(x)=0 -> f(x)=0 when uniqueness is irrelevant to the theorem endpoint"}
+{"applicability_preconditions": "Containment is exactly equivalent to the target relation, not merely a consequence.", "card_id": "TRULE_REMOVE_CONTAINMENT_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_CONTAINMENT_ENCODING\nregistered inverse-operation ID: REMOVE_CONTAINMENT_ENCODING\ndescription: Recover a scalar or relational statement from set containment.\nsurface signature: set containment or subset relation encoding a scalar/relation\ninput types: set containment statement\noutput types: underlying scalar, membership, or relational statement\napplicability preconditions: Containment is exactly equivalent to the target relation, not merely a consequence.\ninverse effect: Recover the relation encoded by the containment.\nschematic valid example: {x: x <= a} subset {x: x <= b} -> a <= b\nforbidden application: Do not invert containment when sets are only approximately or non-strictly related under missing assumptions.", "forbidden_application": "Do not invert containment when sets are only approximately or non-strictly related under missing assumptions.", "index_type": "transform_rule", "input_types": "set containment statement", "inverse_effect": "Recover the relation encoded by the containment.", "inverse_operation_id": "REMOVE_CONTAINMENT_ENCODING", "output_types": "underlying scalar, membership, or relational statement", "rule_id": "TRULE_REMOVE_CONTAINMENT_ENCODING", "sha256": "302dc8ef6731784d4780257c015851611ed0c1f42489fe386af96e170bdabee4", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "set containment or subset relation encoding a scalar/relation", "token_count_approx": 97, "valid_example": "{x: x <= a} subset {x: x <= b} -> a <= b"}
+{"applicability_preconditions": "The cylinder construction is injective with respect to the encoded object.", "card_id": "TRULE_REMOVE_CYLINDER_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_CYLINDER_ENCODING\nregistered inverse-operation ID: REMOVE_CYLINDER_ENCODING\ndescription: Recover pointwise equality from equality of cylinders or sets of pairs.\nsurface signature: cylinder/product-set equality encoding pointwise equality\ninput types: set equality over product/cylinder representation\noutput types: pointwise equality\napplicability preconditions: The cylinder construction is injective with respect to the encoded object.\ninverse effect: Project away the auxiliary cylinder dimensions.\nschematic valid example: A x Z = B x Z with nonempty Z -> A = B\nforbidden application: Do not apply if the auxiliary factor may be empty or if product equality loses information.", "forbidden_application": "Do not apply if the auxiliary factor may be empty or if product equality loses information.", "index_type": "transform_rule", "input_types": "set equality over product/cylinder representation", "inverse_effect": "Project away the auxiliary cylinder dimensions.", "inverse_operation_id": "REMOVE_CYLINDER_ENCODING", "output_types": "pointwise equality", "rule_id": "TRULE_REMOVE_CYLINDER_ENCODING", "sha256": "75365d7ae58ae5b7068e25d314aacdf3995057d588c9f12901c91ea1e873914b", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "cylinder/product-set equality encoding pointwise equality", "token_count_approx": 94, "valid_example": "A x Z = B x Z with nonempty Z -> A = B"}
+{"applicability_preconditions": "The distance is a valid metric or norm and zero distance implies equality/membership.", "card_id": "TRULE_REMOVE_DISTANCE_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_DISTANCE_ENCODING\nregistered inverse-operation ID: REMOVE_DISTANCE_ENCODING\ndescription: Recover equality or membership from a zero-distance statement.\nsurface signature: zero-distance, metric, norm, or residual distance encoding\ninput types: distance/norm statement\noutput types: equality or membership statement\napplicability preconditions: The distance is a valid metric or norm and zero distance implies equality/membership.\ninverse effect: Convert zero-distance/residual condition to equality or membership.\nschematic valid example: d(A,B)=0 -> A=B\nforbidden application: Do not apply to pseudometrics unless zero distance is known to imply equality in the quotient used.", "forbidden_application": "Do not apply to pseudometrics unless zero distance is known to imply equality in the quotient used.", "index_type": "transform_rule", "input_types": "distance/norm statement", "inverse_effect": "Convert zero-distance/residual condition to equality or membership.", "inverse_operation_id": "REMOVE_DISTANCE_ENCODING", "output_types": "equality or membership statement", "rule_id": "TRULE_REMOVE_DISTANCE_ENCODING", "sha256": "b5aed509c2766da09098be2907a30ce64bd21985fb81eec9639b3b8901190b73", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "zero-distance, metric, norm, or residual distance encoding", "token_count_approx": 85, "valid_example": "d(A,B)=0 -> A=B"}
+{"applicability_preconditions": "The map/fiber representation is faithful for the objects being compared.", "card_id": "TRULE_REMOVE_FIBER_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_FIBER_ENCODING\nregistered inverse-operation ID: REMOVE_FIBER_ENCODING\ndescription: Recover equality from equality/identity of fibers or preimages.\nsurface signature: fiber, preimage, or inverse-image equality\ninput types: fiber/preimage statement\noutput types: underlying equality or membership\napplicability preconditions: The map/fiber representation is faithful for the objects being compared.\ninverse effect: Recover the equality encoded by equal fibers or preimages.\nschematic valid example: f^{-1}({a}) = f^{-1}({b}) under injective coding -> a=b\nforbidden application: Do not invert through a non-injective map without an explicit injectivity assumption.", "forbidden_application": "Do not invert through a non-injective map without an explicit injectivity assumption.", "index_type": "transform_rule", "input_types": "fiber/preimage statement", "inverse_effect": "Recover the equality encoded by equal fibers or preimages.", "inverse_operation_id": "REMOVE_FIBER_ENCODING", "output_types": "underlying equality or membership", "rule_id": "TRULE_REMOVE_FIBER_ENCODING", "sha256": "c9efb6b3f06bc52070592d9c3a995e5888e27216cc8cc2066d878f386ba887d6", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "fiber, preimage, or inverse-image equality", "token_count_approx": 82, "valid_example": "f^{-1}({a}) = f^{-1}({b}) under injective coding -> a=b"}
+{"applicability_preconditions": "The intersection condition is equivalent to the relation and introduces no extra solutions.", "card_id": "TRULE_REMOVE_INTERSECTION_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_INTERSECTION_ENCODING\nregistered inverse-operation ID: REMOVE_INTERSECTION_ENCODING\ndescription: Recover equality from a diagonal or graph-intersection construction.\nsurface signature: diagonal, graph intersection, or singleton intersection construction\ninput types: intersection statement\noutput types: equality or relation\napplicability preconditions: The intersection condition is equivalent to the relation and introduces no extra solutions.\ninverse effect: Remove the intersection construction and state the encoded relation.\nschematic valid example: (x,y) in diagonal -> x=y\nforbidden application: Do not apply when intersection only witnesses existence rather than equivalence.", "forbidden_application": "Do not apply when intersection only witnesses existence rather than equivalence.", "index_type": "transform_rule", "input_types": "intersection statement", "inverse_effect": "Remove the intersection construction and state the encoded relation.", "inverse_operation_id": "REMOVE_INTERSECTION_ENCODING", "output_types": "equality or relation", "rule_id": "TRULE_REMOVE_INTERSECTION_ENCODING", "sha256": "937878c8df3199d4c5c88c8becd4c5cfa3708e294264a1206605229c7d368fe6", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "diagonal, graph intersection, or singleton intersection construction", "token_count_approx": 82, "valid_example": "(x,y) in diagonal -> x=y"}
+{"applicability_preconditions": "The function is injective for equality or strictly monotone with correct direction for order.", "card_id": "TRULE_REMOVE_MONOTONE_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_MONOTONE_ENCODING\nregistered inverse-operation ID: REMOVE_MONOTONE_ENCODING\ndescription: Invert a strictly monotone function applied to both sides of a relation.\nsurface signature: strictly monotone function applied to both sides\ninput types: encoded equality or inequality\noutput types: unwrapped equality or inequality\napplicability preconditions: The function is injective for equality or strictly monotone with correct direction for order.\ninverse effect: Apply the inverse monotone function or cancel the monotone wrapper.\nschematic valid example: exp(A)=exp(B) -> A=B\nforbidden application: Do not cancel a non-injective or non-monotone function such as squaring over all real numbers.", "forbidden_application": "Do not cancel a non-injective or non-monotone function such as squaring over all real numbers.", "index_type": "transform_rule", "input_types": "encoded equality or inequality", "inverse_effect": "Apply the inverse monotone function or cancel the monotone wrapper.", "inverse_operation_id": "REMOVE_MONOTONE_ENCODING", "output_types": "unwrapped equality or inequality", "rule_id": "TRULE_REMOVE_MONOTONE_ENCODING", "sha256": "a2ac3c46719adc904bd77306e8aaa7e7c336ec1c158bdff9f2b95ff4668bf669", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "strictly monotone function applied to both sides", "token_count_approx": 93, "valid_example": "exp(A)=exp(B) -> A=B"}
+{"applicability_preconditions": "The optimization problem is a faithful encoding of the target relation under stated assumptions.", "card_id": "TRULE_REMOVE_OPTIMIZATION_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_OPTIMIZATION_ENCODING\nregistered inverse-operation ID: REMOVE_OPTIMIZATION_ENCODING\ndescription: Invert a generic optimization, slack, or residual minimization wrapper.\nsurface signature: optimization/slack/residual minimization wrapper\ninput types: optimization objective or optimality statement\noutput types: canonical relation\napplicability preconditions: The optimization problem is a faithful encoding of the target relation under stated assumptions.\ninverse effect: Recover the relation represented by the optimum/residual condition.\nschematic valid example: min_z ||z-A||^2 = 0 -> z=A at the encoded endpoint\nforbidden application: Do not infer equality from a minimum when multiple optima or approximation error changes the statement.", "forbidden_application": "Do not infer equality from a minimum when multiple optima or approximation error changes the statement.", "index_type": "transform_rule", "input_types": "optimization objective or optimality statement", "inverse_effect": "Recover the relation represented by the optimum/residual condition.", "inverse_operation_id": "REMOVE_OPTIMIZATION_ENCODING", "output_types": "canonical relation", "rule_id": "TRULE_REMOVE_OPTIMIZATION_ENCODING", "sha256": "c5b4993ed0a8f01364f0294ffea932f2b387e32a1e9f85e54745755ec22c949c", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "optimization/slack/residual minimization wrapper", "token_count_approx": 91, "valid_example": "min_z ||z-A||^2 = 0 -> z=A at the encoded endpoint"}
+{"applicability_preconditions": "The desired component is faithfully represented and other components are auxiliary.", "card_id": "TRULE_REMOVE_PAIR_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_PAIR_ENCODING\nregistered inverse-operation ID: REMOVE_PAIR_ENCODING\ndescription: Remove an ordered-pair or product-space encoding.\nsurface signature: ordered pair, tuple, or product-space wrapper\ninput types: tuple equality/relation\noutput types: component equality/relation\napplicability preconditions: The desired component is faithfully represented and other components are auxiliary.\ninverse effect: Project the tuple/product representation to the relevant component relation.\nschematic valid example: (A,C)=(B,C) -> A=B\nforbidden application: Do not drop a component that carries theorem content or changes assumptions.", "forbidden_application": "Do not drop a component that carries theorem content or changes assumptions.", "index_type": "transform_rule", "input_types": "tuple equality/relation", "inverse_effect": "Project the tuple/product representation to the relevant component relation.", "inverse_operation_id": "REMOVE_PAIR_ENCODING", "output_types": "component equality/relation", "rule_id": "TRULE_REMOVE_PAIR_ENCODING", "sha256": "2a98fb1c594f0206d2c69aa1288d2af089ce1dc71d2a0b591f69ea035824c4a0", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "ordered pair, tuple, or product-space wrapper", "token_count_approx": 75, "valid_example": "(A,C)=(B,C) -> A=B"}
+{"applicability_preconditions": "The quantified condition is logically equivalent to the relation in the specified domain.", "card_id": "TRULE_REMOVE_QUANTIFIER_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_QUANTIFIER_ENCODING\nregistered inverse-operation ID: REMOVE_QUANTIFIER_ENCODING\ndescription: Invert a quantified characterization of equality or order.\nsurface signature: forall/exists characterization of equality or order\ninput types: quantified statement\noutput types: canonical relation\napplicability preconditions: The quantified condition is logically equivalent to the relation in the specified domain.\ninverse effect: Replace the quantified characterization by the relation it encodes.\nschematic valid example: forall eps>0, |A-B|<eps -> A=B\nforbidden application: Do not remove a quantifier when it changes the theorem from pointwise to uniform or existential to universal.", "forbidden_application": "Do not remove a quantifier when it changes the theorem from pointwise to uniform or existential to universal.", "index_type": "transform_rule", "input_types": "quantified statement", "inverse_effect": "Replace the quantified characterization by the relation it encodes.", "inverse_operation_id": "REMOVE_QUANTIFIER_ENCODING", "output_types": "canonical relation", "rule_id": "TRULE_REMOVE_QUANTIFIER_ENCODING", "sha256": "5f98ea7b3cb4157c4aba40e06a6076fee0912b97cf784c8e523f611160f19952", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "forall/exists characterization of equality or order", "token_count_approx": 87, "valid_example": "forall eps>0, |A-B|<eps -> A=B"}
+{"applicability_preconditions": "The set is defined exactly as the graph/region of the relation.", "card_id": "TRULE_REMOVE_SET_MEMBERSHIP_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_SET_MEMBERSHIP_ENCODING\nregistered inverse-operation ID: REMOVE_SET_MEMBERSHIP_ENCODING\ndescription: Recover a relation from membership in a cone, interval, singleton, or set.\nsurface signature: membership in cone, interval, singleton, graph, or relation set\ninput types: set-membership statement\noutput types: encoded relation\napplicability preconditions: The set is defined exactly as the graph/region of the relation.\ninverse effect: Translate membership back to the defining relation.\nschematic valid example: (A,B) in {(x,y): x<=y} -> A<=B\nforbidden application: Do not use if the set definition is absent or mismatched to the claimed relation.", "forbidden_application": "Do not use if the set definition is absent or mismatched to the claimed relation.", "index_type": "transform_rule", "input_types": "set-membership statement", "inverse_effect": "Translate membership back to the defining relation.", "inverse_operation_id": "REMOVE_SET_MEMBERSHIP_ENCODING", "output_types": "encoded relation", "rule_id": "TRULE_REMOVE_SET_MEMBERSHIP_ENCODING", "sha256": "bf95044f8e43728addfc28023df6e6857916b407378189ded579039c49de9987", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "membership in cone, interval, singleton, graph, or relation set", "token_count_approx": 88, "valid_example": "(A,B) in {(x,y): x<=y} -> A<=B"}
+{"applicability_preconditions": "The Boolean wrapper is classically equivalent and adds no side condition.", "card_id": "TRULE_REMOVE_TRUTH_TABLE_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_TRUTH_TABLE_ENCODING\nregistered inverse-operation ID: REMOVE_TRUTH_TABLE_ENCODING\ndescription: Remove double negation, tautological conjunction/disjunction, or Boolean encoding.\nsurface signature: Boolean tautology, double negation, redundant conjunction/disjunction\ninput types: Boolean/logical encoding\noutput types: logical proposition\napplicability preconditions: The Boolean wrapper is classically equivalent and adds no side condition.\ninverse effect: Simplify the Boolean encoding to the proposition.\nschematic valid example: not not P -> P\nforbidden application: Do not simplify under non-classical logic or when a disjunct/conjunct changes meaning.", "forbidden_application": "Do not simplify under non-classical logic or when a disjunct/conjunct changes meaning.", "index_type": "transform_rule", "input_types": "Boolean/logical encoding", "inverse_effect": "Simplify the Boolean encoding to the proposition.", "inverse_operation_id": "REMOVE_TRUTH_TABLE_ENCODING", "output_types": "logical proposition", "rule_id": "TRULE_REMOVE_TRUTH_TABLE_ENCODING", "sha256": "24ee39dbd70b7b8387f81bc81b0c9b82b0841d741ed3a4cc6ba4ac4ba570ff23", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "Boolean tautology, double negation, redundant conjunction/disjunction", "token_count_approx": 77, "valid_example": "not not P -> P"}
+{"applicability_preconditions": "The witness is guaranteed to exist exactly when the target relation holds.", "card_id": "TRULE_REMOVE_WITNESS_ENCODING", "card_text": "stable rule ID: TRULE_REMOVE_WITNESS_ENCODING\nregistered inverse-operation ID: REMOVE_WITNESS_ENCODING\ndescription: Eliminate an existential witness that encodes a relation.\nsurface signature: existential witness or auxiliary variable encoding a relation\ninput types: existential statement with witness\noutput types: relation after eliminating witness\napplicability preconditions: The witness is guaranteed to exist exactly when the target relation holds.\ninverse effect: Eliminate the witness and recover the encoded relation.\nschematic valid example: exists w with A=w and w=B -> A=B\nforbidden application: Do not eliminate a witness that imposes extra constraints or only proves one direction.", "forbidden_application": "Do not eliminate a witness that imposes extra constraints or only proves one direction.", "index_type": "transform_rule", "input_types": "existential statement with witness", "inverse_effect": "Eliminate the witness and recover the encoded relation.", "inverse_operation_id": "REMOVE_WITNESS_ENCODING", "output_types": "relation after eliminating witness", "rule_id": "TRULE_REMOVE_WITNESS_ENCODING", "sha256": "1588ca415d3ca8b047504617dc54b76921f12d89769f45365cc68d81c8f4f83d", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "existential witness or auxiliary variable encoding a relation", "token_count_approx": 90, "valid_example": "exists w with A=w and w=B -> A=B"}
+{"applicability_preconditions": "The relation transformation is algebraically/logically reversible.", "card_id": "TRULE_DENORMALIZE_RELATION", "card_text": "stable rule ID: TRULE_DENORMALIZE_RELATION\nregistered inverse-operation ID: DENORMALIZE_RELATION\ndescription: Restore the conventional direction or side ordering of a relation.\nsurface signature: normalized direction, side order, or sign convention for a relation\ninput types: normalized relation\noutput types: canonical orientation of the same relation\napplicability preconditions: The relation transformation is algebraically/logically reversible.\ninverse effect: Restore the conventional direction or side ordering.\nschematic valid example: B >= A -> A <= B\nforbidden application: Do not flip an inequality without also applying a sign-changing operation correctly.", "forbidden_application": "Do not flip an inequality without also applying a sign-changing operation correctly.", "index_type": "transform_rule", "input_types": "normalized relation", "inverse_effect": "Restore the conventional direction or side ordering.", "inverse_operation_id": "DENORMALIZE_RELATION", "output_types": "canonical orientation of the same relation", "rule_id": "TRULE_DENORMALIZE_RELATION", "sha256": "8ce067f80798095f92fd3716d9d92bb400bf59792d13b64b1ce0ef2a38ecf77f", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "normalized direction, side order, or sign convention for a relation", "token_count_approx": 84, "valid_example": "B >= A -> A <= B"}
+{"applicability_preconditions": "The abbreviation is defined in the statement/evidence or is a registered benchmark alias.", "card_id": "TRULE_EXPAND_ABBREVIATIONS", "card_text": "stable rule ID: TRULE_EXPAND_ABBREVIATIONS\nregistered inverse-operation ID: EXPAND_ABBREVIATIONS\ndescription: Expand benchmark abbreviations or shorthand symbols into the canonical form.\nsurface signature: benchmark shorthand, abbreviation, or symbolic alias\ninput types: abbreviated expression\noutput types: expanded canonical expression\napplicability preconditions: The abbreviation is defined in the statement/evidence or is a registered benchmark alias.\ninverse effect: Expand shorthand into the canonical formula.\nschematic valid example: Var(X) -> E[(X-E[X])^2]\nforbidden application: Do not invent an expansion for an undefined symbol.", "forbidden_application": "Do not invent an expansion for an undefined symbol.", "index_type": "transform_rule", "input_types": "abbreviated expression", "inverse_effect": "Expand shorthand into the canonical formula.", "inverse_operation_id": "EXPAND_ABBREVIATIONS", "output_types": "expanded canonical expression", "rule_id": "TRULE_EXPAND_ABBREVIATIONS", "sha256": "197fd5dd4093271cd763104f7d7280fd46f8f7339916c9c341b088ec1307343f", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "benchmark shorthand, abbreviation, or symbolic alias", "token_count_approx": 76, "valid_example": "Var(X) -> E[(X-E[X])^2]"}
+{"applicability_preconditions": "Only use when no registered operation applies; must be justified in free text.", "card_id": "TRULE_OTHER", "card_text": "stable rule ID: TRULE_OTHER\nregistered inverse-operation ID: OTHER\ndescription: A proposed inverse operation outside the registered vocabulary; must be described in operation_free_text.\nsurface signature: unregistered operation\ninput types: unknown\noutput types: unknown\napplicability preconditions: Only use when no registered operation applies; must be justified in free text.\ninverse effect: Unregistered inverse operation proposed by the decoder.\nschematic valid example: N/A\nforbidden application: Do not use OTHER to avoid selecting a registered operation.", "forbidden_application": "Do not use OTHER to avoid selecting a registered operation.", "index_type": "transform_rule", "input_types": "unknown", "inverse_effect": "Unregistered inverse operation proposed by the decoder.", "inverse_operation_id": "OTHER", "output_types": "unknown", "rule_id": "TRULE_OTHER", "sha256": "19a3d1970724d65d4cbaeb1d591dfbef1f3f324d4a00ac543c831dd91e417ab0", "source": "operation_vocabulary_plus_handwritten_theorem_agnostic_rule_templates", "surface_signature": "unregistered operation", "token_count_approx": 72, "valid_example": "N/A"}